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

[gnunet]

Author: wachs
Date: 2012-03-01 13:30:18 +0100 (Thu, 01 Mar 2012)
New Revision: 20167

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_create.c
   gnunet/src/namestore/test_namestore_api_lookup.c
   gnunet/src/namestore/test_namestore_record_serialization.c
Log:
- at least compiling


Modified: gnunet/src/namestore/gnunet-service-namestore.c
===================================================================
--- gnunet/src/namestore/gnunet-service-namestore.c     2012-03-01 12:02:36 UTC 
(rev 20166)
+++ gnunet/src/namestore/gnunet-service-namestore.c     2012-03-01 12:30:18 UTC 
(rev 20167)
@@ -212,7 +212,6 @@
   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;
 
@@ -254,18 +253,22 @@
       copied_elements = rd_count;
       rd_selected = (struct GNUNET_NAMESTORE_RecordData *) rd;
     }
-    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;
     expire = GNUNET_TIME_UNIT_ZERO_ABS;
   }
 
+
+
+  rd_ser_len = GNUNET_NAMESTORE_records_get_size(copied_elements, rd_selected);
+  char rd_ser[rd_ser_len];
+  GNUNET_NAMESTORE_records_serialize(copied_elements, rd_selected, rd_ser_len, 
rd_ser);
+
+
   if ((copied_elements == rd_count) && (signature != NULL))
       contains_signature = GNUNET_YES;
 
@@ -283,6 +286,7 @@
   lnr_msg->gns_header.header.type = ntohs 
(GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE);
   lnr_msg->gns_header.header.size = ntohs (r_size);
   lnr_msg->gns_header.r_id = htonl (lnc->request_id);
+  lnr_msg->rd_count = htons (rd_count);
   lnr_msg->rd_len = htons (rd_ser_len);
   lnr_msg->name_len = htons (name_len);
   lnr_msg->expire = GNUNET_TIME_absolute_hton(expire);
@@ -303,7 +307,6 @@
   }
   memcpy (name_tmp, name, name_len);
   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));
@@ -379,7 +382,6 @@
   struct GNUNET_NAMESTORE_Client *nc;
   struct GNUNET_TIME_Absolute expire;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
-  struct GNUNET_NAMESTORE_RecordData *rd;
   struct GNUNET_CRYPTO_RsaSignature *signature;
   struct RecordPutResponseMessage rpr_msg;
   size_t name_len;
@@ -411,10 +413,11 @@
   struct RecordPutMessage * rp_msg = (struct RecordPutMessage *) message;
 
   rid = ntohl (rp_msg->gns_header.r_id);
+  msg_size = ntohs (rp_msg->gns_header.header.size);
   key_len = sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);
   name_len = ntohs (rp_msg->name_len);
+  rd_count = ntohs (rp_msg->rd_count);
   rd_ser_len = ntohs(rp_msg->rd_len);
-  msg_size = ntohs (message->size);
   msg_size_exp = sizeof (struct RecordPutMessage) + key_len + name_len  + 
rd_ser_len;
 
   if (msg_size != msg_size_exp)
@@ -445,8 +448,10 @@
 
   expire = GNUNET_TIME_absolute_ntoh(rp_msg->expire);
   signature = (struct GNUNET_CRYPTO_RsaSignature *) &rp_msg->signature;
+
   rd_ser = &name[name_len];
-  rd_count = GNUNET_NAMESTORE_records_deserialize(&rd, rd_ser, rd_ser_len);
+  struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+  GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd);
 
   GNUNET_HashCode zone_hash;
   GNUNET_CRYPTO_hash (zone_key, key_len, &zone_hash);
@@ -461,8 +466,6 @@
                                 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");
 
@@ -496,9 +499,11 @@
   struct GNUNET_CRYPTO_RsaSignature *sig = GNUNET_malloc(sizeof (struct 
GNUNET_CRYPTO_RsaSignature));
   struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose;
   size_t rd_ser_len;
-  char *rd_ser;
 
-  rd_ser_len = GNUNET_NAMESTORE_records_serialize(&rd_ser, rd_count, rd);
+  rd_ser_len = GNUNET_NAMESTORE_records_get_size(rd_count, rd);
+  char rd_ser[rd_ser_len];
+  GNUNET_NAMESTORE_records_serialize(rd_count, rd, rd_ser_len, rd_ser);
+
   sig_purpose = GNUNET_malloc(sizeof (struct 
GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len);
 
   sig_purpose->size = htonl (sizeof (struct 
GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len);
@@ -566,7 +571,6 @@
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", 
"NAMESTORE_RECORD_CREATE");
   struct GNUNET_NAMESTORE_Client *nc;
-  struct GNUNET_NAMESTORE_RecordData *rd;
   struct CreateRecordContext crc;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
   GNUNET_HashCode pubkey_hash;
@@ -603,6 +607,7 @@
   rid = ntohl (rp_msg->gns_header.r_id);
   name_len = ntohs (rp_msg->name_len);
   msg_size = ntohs (message->size);
+  rd_count = ntohs (rp_msg->rd_count);
   rd_ser_len = ntohs (rp_msg->rd_len);
   key_len = ntohs (rp_msg->pkey_len);
   msg_size_exp = sizeof (struct RecordCreateMessage) + key_len + name_len + 
rd_ser_len;
@@ -633,7 +638,8 @@
     return;
   }
 
-  rd_count = GNUNET_NAMESTORE_records_deserialize(&rd, rd_ser, rd_ser_len);
+  struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+  GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd);
   GNUNET_assert (rd_count == 1);
 
   /* Extracting and converting private key */
@@ -650,9 +656,6 @@
   /* Get existing records for name */
   res = GSN_database->iterate_records(GSN_database->cls, &pubkey_hash, 
name_tmp, 0, &handle_create_record_it, &crc);
 
-  GNUNET_CRYPTO_rsa_key_free(pkey);
-  GNUNET_NAMESTORE_records_free(rd_count, rd);
-
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -788,7 +791,9 @@
 
   if ((rd_count > 0) && (rd != NULL))
   {
-    len = GNUNET_NAMESTORE_records_serialize (&zipr->rd_ser, rd_count, rd);
+    len = GNUNET_NAMESTORE_records_get_size(rd_count, rd);
+    zipr->rd_ser = GNUNET_malloc (len);
+    GNUNET_NAMESTORE_records_serialize(rd_count, rd, len, zipr->rd_ser);
     zipr->rd_ser_len = len;
   }
 }

Modified: gnunet/src/namestore/namestore.h
===================================================================
--- gnunet/src/namestore/namestore.h    2012-03-01 12:02:36 UTC (rev 20166)
+++ gnunet/src/namestore/namestore.h    2012-03-01 12:30:18 UTC (rev 20167)
@@ -141,6 +141,8 @@
 
   uint16_t rd_len;
 
+  uint16_t rd_count;
+
   int32_t contains_sig;
 
   /* Requested record type */
@@ -167,6 +169,8 @@
   /* Length of serialized rd data */
   uint16_t rd_len;
 
+  uint16_t rd_count;
+
   /* Length of pubkey */
   uint16_t key_len;
 
@@ -220,6 +224,9 @@
   /* Record data length */
   uint16_t rd_len;
 
+  /* Record count */
+  uint16_t rd_count;
+
   /* private key length */
   uint16_t pkey_len;
 };

Modified: gnunet/src/namestore/namestore_api.c
===================================================================
--- gnunet/src/namestore/namestore_api.c        2012-03-01 12:02:36 UTC (rev 
20166)
+++ gnunet/src/namestore/namestore_api.c        2012-03-01 12:30:18 UTC (rev 
20167)
@@ -815,8 +815,8 @@
   memcpy (name_tmp, name, name_len);
   msg->expire = GNUNET_TIME_absolute_hton (expire);
   msg->rd_len = htons (rd_ser_len);
+  msg->rd_count = htons (rd_count);
 
-
   memcpy (rd_tmp, rd_ser, rd_ser_len);
   GNUNET_free (rd_ser);
 
@@ -928,6 +928,7 @@
   msg->gns_header.header.size = htons (msg_size);
   msg->gns_header.r_id = htonl (rid);
   msg->name_len = htons (name_len);
+  msg->rd_count = htons (1);
   msg->rd_len = htons (rd_ser_len);
   msg->pkey_len = htons (key_len);
   memcpy (pkey_tmp, pkey_enc, key_len);

Modified: gnunet/src/namestore/test_namestore_api_create.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_create.c    2012-03-01 12:02:36 UTC 
(rev 20166)
+++ gnunet/src/namestore/test_namestore_api_create.c    2012-03-01 12:30:18 UTC 
(rev 20167)
@@ -286,7 +286,6 @@
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,endbadly, NULL);
-  char * rd_ser;
   size_t rd_ser_len;
 
   /* load privat key */
@@ -298,8 +297,11 @@
   /* create record */
   s_name = "dummy.dummy.gnunet";
   s_rd = create_record (RECORDS);
-  rd_ser_len = GNUNET_NAMESTORE_records_serialize(&rd_ser, RECORDS, s_rd);
 
+  rd_ser_len = GNUNET_NAMESTORE_records_get_size(RECORDS, s_rd);
+  char rd_ser[rd_ser_len];
+  GNUNET_NAMESTORE_records_serialize(RECORDS, s_rd, rd_ser_len, rd_ser);
+
   /* sign */
   struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose = GNUNET_malloc(sizeof 
(struct GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len);
   sig_purpose->size = htonl (sizeof (struct 
GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len);

Modified: gnunet/src/namestore/test_namestore_api_lookup.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_lookup.c    2012-03-01 12:02:36 UTC 
(rev 20166)
+++ gnunet/src/namestore/test_namestore_api_lookup.c    2012-03-01 12:30:18 UTC 
(rev 20167)
@@ -232,7 +232,7 @@
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,endbadly, NULL);
-  char * rd_ser;
+
   size_t rd_ser_len;
 
   /* load privat key */
@@ -244,8 +244,11 @@
   /* create record */
   s_name = "dummy.dummy.gnunet";
   s_rd = create_record (RECORDS);
-  rd_ser_len = GNUNET_NAMESTORE_records_serialize(&rd_ser, RECORDS, s_rd);
 
+  rd_ser_len = GNUNET_NAMESTORE_records_get_size(RECORDS, s_rd);
+  char rd_ser[rd_ser_len];
+  GNUNET_NAMESTORE_records_serialize(RECORDS, s_rd, rd_ser_len, rd_ser);
+
   /* sign */
   struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose = GNUNET_malloc(sizeof 
(struct GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len);
   sig_purpose->size = htonl (sizeof (struct 
GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len);

Modified: gnunet/src/namestore/test_namestore_record_serialization.c
===================================================================
--- gnunet/src/namestore/test_namestore_record_serialization.c  2012-03-01 
12:02:36 UTC (rev 20166)
+++ gnunet/src/namestore/test_namestore_record_serialization.c  2012-03-01 
12:30:18 UTC (rev 20167)
@@ -36,15 +36,12 @@
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  char * rd_ser = NULL;
   size_t len;
   int c;
-  int dst_elem = 0;
 
   int rd_count = 3;
   size_t data_len;
   struct GNUNET_NAMESTORE_RecordData src[rd_count];
-  struct GNUNET_NAMESTORE_RecordData *dst = NULL;
 
   memset(src, '\0', rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData));
 
@@ -61,18 +58,20 @@
   }
   res = 0;
 
-  len = GNUNET_NAMESTORE_records_serialize (&rd_ser, rd_count, src);
+  len = GNUNET_NAMESTORE_records_get_size(rd_count, src);
+  char rd_ser[len];
+  GNUNET_assert (len == GNUNET_NAMESTORE_records_serialize(rd_count, src, len, 
rd_ser));
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Serialized data len: %u\n",len);
 
   GNUNET_assert (rd_ser != NULL);
 
-  dst_elem = GNUNET_NAMESTORE_records_deserialize(&dst, rd_ser, len);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deserialized elements: %u\n",dst_elem);
+  struct GNUNET_NAMESTORE_RecordData dst[rd_count];
+  GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_records_deserialize (len, 
rd_ser, rd_count, dst));
 
-  GNUNET_assert (dst_elem == rd_count);
   GNUNET_assert (dst != NULL);
 
-  for (c = 0; c < dst_elem; c++)
+  for (c = 0; c < rd_count; c++)
   {
     if (src[c].data_size != dst[c].data_size)
     {
@@ -116,11 +115,6 @@
 
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Element [%i]: EQUAL\n", c);
   }
-
-  for (c = 0; c < rd_count; c++)
-    GNUNET_free ((void *)  src[c].data);
-  GNUNET_NAMESTORE_records_free (dst_elem, dst);
-  GNUNET_free (rd_ser);
 }
 
 static int