[GNUnet-SVN] r30412 - gnunet/src/namestore

[gnunet]

Author: wachs
Date: 2013-10-25 17:36:32 +0200 (Fri, 25 Oct 2013)
New Revision: 30412

Modified:
   gnunet/src/namestore/gnunet-service-namestore.c
   gnunet/src/namestore/namestore.h
   gnunet/src/namestore/namestore_api.c
   gnunet/src/namestore/test_namestore_api_lookup_private.c
Log:
api communication done


Modified: gnunet/src/namestore/gnunet-service-namestore.c
===================================================================
--- gnunet/src/namestore/gnunet-service-namestore.c     2013-10-25 15:16:16 UTC 
(rev 30411)
+++ gnunet/src/namestore/gnunet-service-namestore.c     2013-10-25 15:36:32 UTC 
(rev 30412)
@@ -561,6 +561,48 @@
   GNUNET_free (block);
 }
 
+
+struct RecordLookupContext
+{
+  const char *label;
+
+  int found;
+
+  unsigned int res_rd_count;
+
+  size_t rd_ser_len;
+
+  char *res_rd;
+};
+
+static void lookup_it (void *cls,
+                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
+                       const char *label,
+                       unsigned int rd_count,
+                       const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct RecordLookupContext *rlc = cls;
+
+  if (0 == strcmp (label, rlc->label))
+  {
+    rlc->found = GNUNET_YES;
+    if (0 != rd_count)
+    {
+      rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
+      rlc->res_rd_count = rd_count;
+      rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
+      GNUNET_GNSRECORD_records_serialize (rd_count, rd, rlc->rd_ser_len , 
rlc->res_rd);
+    }
+    else
+    {
+      rlc->rd_ser_len = 0;
+      rlc->res_rd_count = 0;
+      rlc->res_rd = NULL;
+    }
+  }
+}
+
+
 /**
  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message
  *
@@ -573,11 +615,16 @@
                      struct GNUNET_SERVER_Client *client,
                      const struct GNUNET_MessageHeader *message)
 {
-  const struct LabelLookupMessage * ll_msg;
+  const struct LabelLookupMessage *ll_msg;
+  struct LabelLookupResponseMessage *llr_msg;
+  struct RecordLookupContext rlc;
   const char *name_tmp;
-  uint32_t rid;
+  char *res_name;
   uint32_t name_len;
-  size_t msg_size;
+  size_t src_size;
+  size_t res_size;
+  int offset;
+  int res;
 
   if (ntohs (message->size) < sizeof (struct LabelLookupMessage))
   {
@@ -587,21 +634,64 @@
   }
 
   ll_msg = (const struct LabelLookupMessage *) message;
-  rid = ntohl (ll_msg->gns_header.r_id);
-  name_len = ntohs (ll_msg->label_len);
-  msg_size = ntohs (message->size);
+  name_len = ntohl (ll_msg->label_len);
+  src_size = ntohs (message->size);
 
-  if (name_len !=  msg_size - sizeof (struct LabelLookupMessage))
+  if (name_len !=  src_size - sizeof (struct LabelLookupMessage))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-  name_tmp = &ll_msg[1];
 
+  name_tmp = (const char *) &ll_msg[1];
+  if ('\0' != name_tmp[name_len -1])
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' message for name `%s'\n",
               "NAMESTORE_RECORD_LOOKUP", name_tmp);
+
+
+  rlc.label = name_tmp;
+  rlc.found = GNUNET_NO;
+  rlc.res_rd_count = 0;
+  rlc.rd_ser_len = 0;
+  rlc.res_rd = NULL;
+
+  offset = 0;
+  do
+  {
+    /* changee this call */
+    res = GSN_database->iterate_records (GSN_database->cls,
+        &ll_msg->zone, offset, &lookup_it, &rlc);
+    offset++;
+  }
+  while ((GNUNET_NO == rlc.found) && (GNUNET_OK == res));
+
+  res_size = sizeof (struct LabelLookupResponseMessage) + name_len + 
rlc.rd_ser_len;
+  llr_msg = GNUNET_malloc (res_size);
+  llr_msg->gns_header.header.size = htons (res_size);
+  llr_msg->gns_header.header.type = htons 
(GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE);
+  llr_msg->gns_header.r_id = ll_msg->gns_header.r_id;
+  llr_msg->private_key = ll_msg->zone;
+  llr_msg->name_len = htons (name_len);
+  llr_msg->rd_count = htons (rlc.res_rd_count);
+  llr_msg->rd_len = htons (rlc.rd_ser_len);
+  res_name = (char *) &llr_msg[1];
+  memcpy (&llr_msg[1], name_tmp, name_len);
+  memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len);
+
+  GNUNET_SERVER_notification_context_unicast (snc, client, 
&llr_msg->gns_header.header,
+      GNUNET_NO);
+
+  GNUNET_free_non_null (rlc.res_rd);
+  GNUNET_free (llr_msg);
 }
 
 
@@ -963,7 +1053,7 @@
  * @param rd record data
  */
 static void
-zone_iteraterate_proc (void *cls,
+zone_iterate_proc (void *cls,
                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
                        const char *name,
                        unsigned int rd_count,
@@ -1036,7 +1126,7 @@
                                              ? NULL
                                              : &zi->zone,
                                              zi->offset,
-                                             &zone_iteraterate_proc, &proc)))
+                                             &zone_iterate_proc, &proc)))
     {
       GNUNET_break (0);
       break;

Modified: gnunet/src/namestore/namestore.h
===================================================================
--- gnunet/src/namestore/namestore.h    2013-10-25 15:16:16 UTC (rev 30411)
+++ gnunet/src/namestore/namestore.h    2013-10-25 15:36:32 UTC (rev 30412)
@@ -235,8 +235,49 @@
 };
 
 
+/**
+ * Lookup a label
+ */
+struct LabelLookupResponseMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
+   */
+  struct GNUNET_NAMESTORE_Header gns_header;
 
+  /**
+   * Name length
+   */
+  uint16_t name_len GNUNET_PACKED;
 
+  /**
+   * Length of serialized record data
+   */
+  uint16_t rd_len GNUNET_PACKED;
+
+  /**
+   * Number of records contained
+   */
+  uint16_t rd_count GNUNET_PACKED;
+
+  /**
+   * always zero (for alignment)
+   */
+  uint16_t reserved GNUNET_PACKED;
+
+  /**
+   * The private key of the authority.
+   */
+  struct GNUNET_CRYPTO_EcdsaPrivateKey private_key;
+
+  /* followed by:
+   * name with length name_len
+   * serialized record data with rd_count records
+   */
+};
+
+
+
 /**
  * Lookup a name for a zone hash
  */

Modified: gnunet/src/namestore/namestore_api.c
===================================================================
--- gnunet/src/namestore/namestore_api.c        2013-10-25 15:16:16 UTC (rev 
30411)
+++ gnunet/src/namestore/namestore_api.c        2013-10-25 15:36:32 UTC (rev 
30412)
@@ -281,6 +281,72 @@
 
 /**
  * Handle an incoming message of type
+ * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
+ *
+ * @param qe the respective entry in the message queue
+ * @param msg the message we received
+ * @param size the message size
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT 
notify the client
+ */
+static int
+handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
+                      const struct LabelLookupResponseMessage *msg,
+                      size_t size)
+{
+  const char *name;
+  const char *rd_tmp;
+  size_t exp_msg_len;
+  size_t msg_len;
+  size_t name_len;
+  size_t rd_len;
+  unsigned int rd_count;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received `%s'\n",
+       "RECORD_LOOKUP_RESULT");
+
+  rd_len = ntohs (msg->rd_len);
+  rd_count = ntohs (msg->rd_count);
+  msg_len = ntohs (msg->gns_header.header.size);
+  name_len = ntohs (msg->name_len);
+  GNUNET_break (0 == ntohs (msg->reserved));
+  exp_msg_len = sizeof (struct LabelLookupResponseMessage) + name_len + rd_len;
+  if (msg_len != exp_msg_len)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  name = (const char *) &msg[1];
+  if ( (name_len > 0) &&
+       ('\0' != name[name_len -1]) )
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  rd_tmp = &name[name_len];
+  {
+    struct GNUNET_GNSRECORD_Data rd[rd_count];
+
+    if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, 
rd_count, rd))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+    if (0 == name_len)
+      name = NULL;
+    if (NULL != qe->proc)
+      qe->proc (qe->proc_cls,
+                &msg->private_key,
+                name,
+                rd_count,
+                (rd_count > 0) ? rd : NULL);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle an incoming message of type
  * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT
  *
  * @param qe the respective entry in the message queue
@@ -462,6 +528,13 @@
       return GNUNET_SYSERR;
     }
     return handle_record_result (qe, (const struct RecordResultMessage *) msg, 
size);
+  case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE:
+    if (size < sizeof (struct LabelLookupResponseMessage))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+    return handle_lookup_result (qe, (const struct LabelLookupResponseMessage 
*) msg, size);
   default:
     GNUNET_break (0);
     return GNUNET_SYSERR;
@@ -1026,7 +1099,7 @@
   msg->gns_header.header.size = htons (msg_size);
   msg->gns_header.r_id = htonl (qe->op_id);
   msg->zone = *pkey;
-  msg->label_len = htons(label_len);
+  msg->label_len = htonl(label_len);
   memcpy (&msg[1], label, label_len);
 
   /* transmit message */

Modified: gnunet/src/namestore/test_namestore_api_lookup_private.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_lookup_private.c    2013-10-25 
15:16:16 UTC (rev 30411)
+++ gnunet/src/namestore/test_namestore_api_lookup_private.c    2013-10-25 
15:36:32 UTC (rev 30412)
@@ -45,7 +45,8 @@
 
 static struct GNUNET_NAMESTORE_QueueEntry *nsqe;
 
-static const char * name = "dummy.dummy.gnunet";
+//static const char * name = "dummy.dummy.gnunet";
+static const char * name = "d";
 
 static void
 cleanup ()
@@ -96,14 +97,45 @@
                 unsigned int rd_count,
                 const struct GNUNET_GNSRECORD_Data *rd)
 {
- nsqe = NULL;
- /* Check here */
+  nsqe = NULL;
 
+  if (0 != memcmp(privkey, zone, sizeof (struct 
GNUNET_CRYPTO_EcdsaPrivateKey)))
+  {
+    GNUNET_break(0);
+    GNUNET_SCHEDULER_cancel (endbadly_task);
+    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
+    return;
+  }
 
+
+  if (NULL == label)
+  {
+    GNUNET_break(0);
+    GNUNET_SCHEDULER_cancel (endbadly_task);
+    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
+    return;
+  }
+
+  if (0 != strcmp (label, name))
+  {
+    GNUNET_break(0);
+    GNUNET_SCHEDULER_cancel (endbadly_task);
+    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
+    return;
+  }
+
+  if (1 != rd_count)
+  {
+    GNUNET_break(0);
+    GNUNET_SCHEDULER_cancel (endbadly_task);
+    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
+    return;
+  }
+
   /* Done */
   GNUNET_SCHEDULER_cancel (endbadly_task);
   endbadly_task = GNUNET_SCHEDULER_NO_TASK;
-  GNUNET_SCHEDULER_add_now (&end, NULL);
+  GNUNET_SCHEDULER_add_now (&end, NULL );
 }