- more changes

diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c
index 92eb218b937acce540f61ec89ec5977da1c203e4..3640e678ba5626b6022361929ccbe2335b0e0b9b 100644 (file)
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.c
@@ -208,8 +208,11 @@ handle_lookup_name_it (void *cls,
   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 @@ handle_lookup_name_it (void *cls,
       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 @@ handle_lookup_name_it (void *cls,
   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 @@ handle_lookup_name_it (void *cls,
     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 @@ static void handle_record_put (void *cls,
                                 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 @@ struct ZoneIterationProcResult
   int have_name;
   char name[256];
 
-  unsigned int rd_count;
+  size_t rd_ser_len;
   char *rd_ser;
 };
 
@@ -628,8 +644,6 @@ void zone_iteration_proc (void *cls,
   else
     zipr->have_name = GNUNET_NO;
 
-  zipr->rd_count = rd_count;
-
   if (signature != NULL)
   {
     zipr->signature = *signature;
@@ -641,6 +655,7 @@ void zone_iteration_proc (void *cls,
   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 @@ static void handle_iteration_start (void *cls,
   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);
 
 

diff --git a/src/namestore/namestore.h b/src/namestore/namestore.h
index 22fc860ebcf984b72c86e4e262429e1c8dd75072..14a13801a6d8f6f62c08598efc34db201bbe3121 100644 (file)
--- a/src/namestore/namestore.h
+++ b/src/namestore/namestore.h
@@ -51,6 +51,9 @@ GNUNET_NAMESTORE_records_serialize (char ** dest,
 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 @@ struct LookupNameResponseMessage
   uint16_t contains_sig;
 
   /* Requested record type */
-  uint32_t rc_count;
+  uint32_t rd_len;
 };
 GNUNET_NETWORK_STRUCT_END
 
@@ -416,6 +419,16 @@ struct ZoneIterationResponseMessage
    * 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
 

diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c
index 1d41399c602728541c707169718e20e279e60e6a..943ede51912d44c9f0e39f22f9134cdd03a682db 100644 (file)
--- a/src/namestore/namestore_api.c
+++ b/src/namestore/namestore_api.c
@@ -200,16 +200,18 @@ handle_lookup_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
   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 @@ handle_lookup_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
   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 @@ handle_lookup_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
 
   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 @@ handle_lookup_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
   {
     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);

diff --git a/src/namestore/namestore_common.c b/src/namestore/namestore_common.c
index 37f0eab0b3613afc1bf1a7fbc1264e2099213668..7112303513ff2a359dd3701bd28f242b10c359a0 100644 (file)
--- a/src/namestore/namestore_common.c
+++ b/src/namestore/namestore_common.c
@@ -55,6 +55,7 @@ GNUNET_NAMESTORE_records_serialize (char ** dest,
   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,6 +95,18 @@ GNUNET_NAMESTORE_records_serialize (char ** dest,
   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
@@ -142,8 +155,10 @@ GNUNET_NAMESTORE_records_deserialize ( struct GNUNET_NAMESTORE_RecordData **dest
     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);