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

[gnunet]

Author: wachs
Date: 2012-02-28 19:00:07 +0100 (Tue, 28 Feb 2012)
New Revision: 20125

Modified:
   gnunet/src/namestore/gnunet-service-namestore.c
   gnunet/src/namestore/namestore.h
   gnunet/src/namestore/namestore_api.c
   gnunet/src/namestore/namestore_common.c
Log:
- more changes


Modified: gnunet/src/namestore/gnunet-service-namestore.c
===================================================================
--- gnunet/src/namestore/gnunet-service-namestore.c     2012-02-28 17:44:57 UTC 
(rev 20124)
+++ gnunet/src/namestore/gnunet-service-namestore.c     2012-02-28 18:00:07 UTC 
(rev 20125)
@@ -208,8 +208,11 @@
   struct LookupNameResponseMessage *lnr_msg;
 
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key_tmp;
-  struct GNUNET_NAMESTORE_RecordData * rd_tmp;
+  struct GNUNET_NAMESTORE_RecordData *rd_selected = NULL;
+  char *rd_tmp;
   char *name_tmp;
+  char *rd_ser;
+  size_t rd_ser_len;
   struct GNUNET_CRYPTO_RsaSignature *signature_tmp;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", 
"NAMESTORE_LOOKUP_NAME_RESPONSE");
@@ -233,18 +236,46 @@
       for (c = 0; c < rd_count; c ++)
         if (rd[c].record_type == lnc->record_type)
           copied_elements++; /* found matching record */
+      rd_selected = GNUNET_malloc (copied_elements * sizeof (struct 
GNUNET_NAMESTORE_RecordData));
+      copied_elements = 0;
+      for (c = 0; c < rd_count; c ++)
+      {
+        if (rd[c].record_type == lnc->record_type)
+        {
+          /* found matching record */
+          memcpy (&rd_selected[copied_elements], &rd[c], sizeof (struct 
GNUNET_NAMESTORE_RecordData));
+          copied_elements++;
+        }
+      }
     }
     else
+    {
       copied_elements = rd_count;
+      rd_selected = (struct GNUNET_NAMESTORE_RecordData *) rd;
+    }
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "NAMESTORE_LOOKUP_NAME_RESPONSE: %p 
%u\n", rd_selected, copied_elements);
+    rd_ser_len = GNUNET_NAMESTORE_records_serialize(&rd_ser, copied_elements, 
rd_selected);
   }
+  else
+  {
+    /* No results */
+    copied_elements = 0;
+    rd_selected = NULL;
+    rd_ser = NULL;
+    rd_ser_len = 0;
+  }
 
   if ((copied_elements == rd_count) && (signature != NULL))
       contains_signature = GNUNET_YES;
 
+  if (rd_selected != rd)
+    GNUNET_free (rd_selected);
+
   r_size = sizeof (struct LookupNameResponseMessage) +
            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
            name_len +
-           copied_elements * sizeof (struct GNUNET_NAMESTORE_RecordData) +
+           rd_ser_len +
            contains_signature * sizeof (struct GNUNET_CRYPTO_RsaSignature);
 
   lnr_msg = GNUNET_malloc (r_size);
@@ -252,16 +283,15 @@
   lnr_msg->header.type = ntohs 
(GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE);
   lnr_msg->header.size = ntohs (r_size);
   lnr_msg->op_id = htonl (lnc->id);
-  lnr_msg->rc_count = htonl (copied_elements);
+  lnr_msg->rd_len = htonl (rd_ser_len);
   lnr_msg->name_len = htons (name_len);
   lnr_msg->expire = GNUNET_TIME_absolute_hton(expire);
   lnr_msg->contains_sig = htons (contains_signature);
 
-
   zone_key_tmp =  (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) 
&lnr_msg[1];
   name_tmp = (char *) &zone_key_tmp[1];
-  rd_tmp = (struct GNUNET_NAMESTORE_RecordData *) &name_tmp[name_len];
-  signature_tmp = (struct GNUNET_CRYPTO_RsaSignature *) 
&rd_tmp[copied_elements];
+  rd_tmp = &name_tmp[name_len];
+  signature_tmp = (struct GNUNET_CRYPTO_RsaSignature *) &rd_tmp[rd_ser_len];
 
   if (zone_key != NULL)
     memcpy (zone_key_tmp, zone_key, sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
@@ -272,24 +302,8 @@
     memcpy (zone_key_tmp, &dummy, sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
   }
   memcpy (name_tmp, name, name_len);
-  /* copy records */
-  copied_elements = 0;
-  if (rd_count != 0)
-  {
-    if (lnc->record_type != 0)
-    {
-      /* special record type needed */
-      for (c = 0; c < rd_count; c ++)
-        if (rd[c].record_type == lnc->record_type)
-        {
-          /* found matching record */
-          memcpy (&rd_tmp[copied_elements], &rd[c], rd_count * sizeof (struct 
GNUNET_NAMESTORE_RecordData));
-          copied_elements++;
-        }
-    }
-    else
-      memcpy (rd_tmp, rd, rd_count * sizeof (struct 
GNUNET_NAMESTORE_RecordData));
-  }
+  memcpy (rd_tmp, rd_ser, rd_ser_len);
+  GNUNET_free_non_null (rd_ser);
 
   if (GNUNET_YES == contains_signature)
     memcpy (signature_tmp, signature, sizeof (struct 
GNUNET_CRYPTO_RsaSignature));
@@ -428,6 +442,8 @@
                                 rd_count, rd,
                                 signature);
 
+  GNUNET_NAMESTORE_records_free (rd_count, rd);
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Putting record for name `%s': %s\n",
       name, (res == GNUNET_OK) ? "OK" : "FAIL");
 
@@ -595,7 +611,7 @@
   int have_name;
   char name[256];
 
-  unsigned int rd_count;
+  size_t rd_ser_len;
   char *rd_ser;
 };
 
@@ -628,8 +644,6 @@
   else
     zipr->have_name = GNUNET_NO;
 
-  zipr->rd_count = rd_count;
-
   if (signature != NULL)
   {
     zipr->signature = *signature;
@@ -641,6 +655,7 @@
   if ((rd_count > 0) && (rd != NULL))
   {
     len = GNUNET_NAMESTORE_records_serialize (&zipr->rd_ser, rd_count, rd);
+    zipr->rd_ser_len = len;
   }
 }
 
@@ -674,12 +689,30 @@
   GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi);
 
   res = GSN_database->iterate_records (GSN_database->cls, &zis_msg->zone, 
NULL, zi->offset , &zone_iteration_proc, &zipr);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "iterate_records result %u\n", res);
+  switch (res) {
+    case GNUNET_OK:
+      /* GNUNET_OK on success */
 
+      break;
+    case GNUNET_SYSERR:
+      /* GNUNET_SYSERR on error */
+      break;
+    case GNUNET_NO:
+      /* GNUNET_NO if there were no results, */
+      break;
+    default:
+      break;
+  }
+
+
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", 
"ZONE_ITERATION_RESPONSE");
   zir_msg.header.type = htons 
(GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_RESPONSE);
   zir_msg.op_id = htonl(zi->op_id);
   zir_msg.header.size = htons (sizeof (struct ZoneIterationResponseMessage));
 
+
   GNUNET_SERVER_notification_context_unicast (snc, zi->client->client, (const 
struct GNUNET_MessageHeader *) &zir_msg, GNUNET_NO);
 
 

Modified: gnunet/src/namestore/namestore.h
===================================================================
--- gnunet/src/namestore/namestore.h    2012-02-28 17:44:57 UTC (rev 20124)
+++ gnunet/src/namestore/namestore.h    2012-02-28 18:00:07 UTC (rev 20125)
@@ -51,6 +51,9 @@
 int
 GNUNET_NAMESTORE_records_deserialize ( struct GNUNET_NAMESTORE_RecordData 
**dest, char *src, size_t len);
 
+void
+GNUNET_NAMESTORE_records_free (unsigned int rd_count, struct 
GNUNET_NAMESTORE_RecordData *rd);
+
 /**
  * A GNS record serialized for network transmission.
  * layout is [struct GNUNET_NAMESTORE_NetworkRecord][char[data_size] data]
@@ -168,7 +171,7 @@
   uint16_t contains_sig;
 
   /* Requested record type */
-  uint32_t rc_count;
+  uint32_t rd_len;
 };
 GNUNET_NETWORK_STRUCT_END
 
@@ -416,6 +419,16 @@
    * Operation ID in NBO
    */
   uint32_t op_id;
+
+  struct GNUNET_TIME_AbsoluteNBO expire;
+
+  uint16_t name_len;
+
+  uint16_t contains_sig;
+
+  /* Record data length */
+  uint16_t rd_len;
+
 };
 GNUNET_NETWORK_STRUCT_END
 

Modified: gnunet/src/namestore/namestore_api.c
===================================================================
--- gnunet/src/namestore/namestore_api.c        2012-02-28 17:44:57 UTC (rev 
20124)
+++ gnunet/src/namestore/namestore_api.c        2012-02-28 18:00:07 UTC (rev 
20125)
@@ -200,16 +200,18 @@
   struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
   char *name;
+  char * rd_tmp;
   struct GNUNET_NAMESTORE_RecordData *rd = NULL;
   struct GNUNET_CRYPTO_RsaSignature *signature = NULL;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded dummy;
   struct GNUNET_TIME_Absolute expire;
-  unsigned int rd_count = 0;
   size_t msg_len = 0;
   size_t name_len = 0;
+  size_t rd_len = 0;
   int contains_sig = GNUNET_NO;
+  int rd_count = 0;
 
-  rd_count = ntohl (msg->rc_count);
+  rd_len = ntohs (msg->rd_len);
   msg_len = ntohs (msg->header.size);
   name_len = ntohs (msg->name_len);
   contains_sig = ntohs (msg->contains_sig);
@@ -218,7 +220,7 @@
   if (msg_len != sizeof (struct LookupNameResponseMessage) +
       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
       name_len +
-      rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData) +
+      rd_len +
       contains_sig * sizeof (struct GNUNET_CRYPTO_RsaSignature))
   {
     GNUNET_break_op (0);
@@ -227,13 +229,14 @@
 
   zone_key = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &msg[1];
   name = (char *) &zone_key[1];
-  rd = (struct GNUNET_NAMESTORE_RecordData *) &name[name_len];
+  rd_tmp = &name[name_len];
+  rd_count = GNUNET_NAMESTORE_records_deserialize(&rd, rd_tmp, rd_len);
 
   /* reset values if values not contained */
   if (contains_sig == GNUNET_NO)
     signature = NULL;
   else
-    signature = (struct GNUNET_CRYPTO_RsaSignature *) &rd[rd_count];
+    signature = (struct GNUNET_CRYPTO_RsaSignature *) &rd_tmp[rd_len];
   if (rd_count == 0)
     rd = NULL;
   if (name_len == 0)
@@ -247,6 +250,9 @@
   {
     qe->proc (qe->proc_cls, zone_key, expire, name, rd_count, rd, signature);
   }
+
+  GNUNET_NAMESTORE_records_free(rd_count, rd);
+
   /* Operation done, remove */
   GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
   GNUNET_free (qe);

Modified: gnunet/src/namestore/namestore_common.c
===================================================================
--- gnunet/src/namestore/namestore_common.c     2012-02-28 17:44:57 UTC (rev 
20124)
+++ gnunet/src/namestore/namestore_common.c     2012-02-28 18:00:07 UTC (rev 
20125)
@@ -55,6 +55,7 @@
   int c = 0;
   int offset;
 
+  GNUNET_assert (rd != NULL);
 
   size_t total_len = rd_count * sizeof (struct GNUNET_NAMESTORE_NetworkRecord);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Struct size: %u\n", total_len);
@@ -94,7 +95,19 @@
   return total_len;
 }
 
+void
+GNUNET_NAMESTORE_records_free (unsigned int rd_count, struct 
GNUNET_NAMESTORE_RecordData *rd)
+{
+  int c;
+  if ((rd == NULL) || (rd_count == 0))
+    return;
 
+  for (c = 0; c < rd_count; c++)
+    GNUNET_free_non_null ((void *) rd[c].data);
+  GNUNET_free (rd);
+}
+
+
 /**
  * Deserialize an array of GNUNET_NAMESTORE_RecordData *rd after transmission
  * over the network
@@ -142,8 +155,10 @@
     d[c].record_type = ntohl (nr->record_type);
     d[c].flags = ntohl (nr->flags);
     d[c].data_size = ntohl (nr->data_size);
-    d[c].data = GNUNET_malloc (d[c].data_size);
-    GNUNET_assert (d[c].data != NULL);
+    if (d[c].data_size > 0)
+      d[c].data = GNUNET_malloc (d[c].data_size);
+    else
+      d[c].data = NULL;
 
     offset += sizeof (struct GNUNET_NAMESTORE_NetworkRecord);
     memcpy((char *) d[c].data, &src[offset], d[c].data_size);