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

[gnunet]

Author: wachs
Date: 2012-02-29 20:21:45 +0100 (Wed, 29 Feb 2012)
New Revision: 20151

Modified:
   gnunet/src/namestore/Makefile.am
   gnunet/src/namestore/gnunet-service-namestore.c
   gnunet/src/namestore/namestore.h
   gnunet/src/namestore/namestore_api.c
   gnunet/src/namestore/test_namestore_api_put.c
   gnunet/src/namestore/test_namestore_record_serialization.c
Log:
- namestore


Modified: gnunet/src/namestore/Makefile.am
===================================================================
--- gnunet/src/namestore/Makefile.am    2012-02-29 19:21:20 UTC (rev 20150)
+++ gnunet/src/namestore/Makefile.am    2012-02-29 19:21:45 UTC (rev 20151)
@@ -27,6 +27,7 @@
  test_namestore_api \
  test_namestore_api_put \
  test_namestore_api_lookup \
+ test_namestore_api_create \
  test_namestore_api_zone_iteration \
  test_namestore_record_serialization
 
@@ -93,6 +94,12 @@
   $(top_builddir)/src/util/libgnunetutil.la \
   $(top_builddir)/src/namestore/libgnunetnamestore.la
 
+test_namestore_api_create_SOURCES = \
+ test_namestore_api_create.c
+test_namestore_api_create_LDADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/namestore/libgnunetnamestore.la
+
 test_namestore_api_zone_iteration_SOURCES = \
  test_namestore_api_zone_iteration.c
 test_namestore_api_zone_iteration_LDADD = \

Modified: gnunet/src/namestore/gnunet-service-namestore.c
===================================================================
--- gnunet/src/namestore/gnunet-service-namestore.c     2012-02-29 19:21:20 UTC 
(rev 20150)
+++ gnunet/src/namestore/gnunet-service-namestore.c     2012-02-29 19:21:45 UTC 
(rev 20151)
@@ -28,6 +28,7 @@
 #include "gnunet_service_lib.h"
 #include "gnunet_namestore_service.h"
 #include "gnunet_namestore_plugin.h"
+#include "gnunet_signatures.h"
 #include "namestore.h"
 
 
@@ -262,6 +263,7 @@
     rd_selected = NULL;
     rd_ser = NULL;
     rd_ser_len = 0;
+    expire = GNUNET_TIME_UNIT_ZERO_ABS;
   }
 
   if ((copied_elements == rd_count) && (signature != NULL))
@@ -281,7 +283,7 @@
   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->rd_len = htonl (rd_ser_len);
+  lnr_msg->rd_len = htons (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);
@@ -383,6 +385,7 @@
   size_t name_len;
   size_t msg_size;
   size_t msg_size_exp;
+  size_t key_len;
   char * name;
   char * rd_ser;
   uint32_t id = 0;
@@ -406,11 +409,13 @@
   }
 
   struct RecordPutMessage * rp_msg = (struct RecordPutMessage *) message;
+
   id = ntohl (rp_msg->op_id);
+  key_len = sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);
   name_len = ntohs (rp_msg->name_len);
   rd_ser_len = ntohs(rp_msg->rd_len);
   msg_size = ntohs (message->size);
-  msg_size_exp = sizeof (struct RecordPutMessage) + sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + name_len  + rd_ser_len;
+  msg_size_exp = sizeof (struct RecordPutMessage) + key_len + name_len  + 
rd_ser_len;
 
   if (msg_size != msg_size_exp)
   {
@@ -429,7 +434,7 @@
   }
 
   zone_key = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &rp_msg[1];
-  name = (char *) &zone_key[1];
+  name =  &((char *)zone_key)[key_len];
 
   if (name[name_len -1] != '\0')
   {
@@ -443,6 +448,11 @@
   rd_ser = &name[name_len];
   rd_count = GNUNET_NAMESTORE_records_deserialize(&rd, rd_ser, rd_ser_len);
 
+  GNUNET_HashCode zone_hash;
+  GNUNET_CRYPTO_hash (zone_key, key_len, &zone_hash);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "PUT ZONE HASH: `%s'\n", 
GNUNET_h2s_full(&zone_hash));
+
+
   /* Database operation */
   res = GSN_database->put_records(GSN_database->cls,
                                 zone_key,
@@ -471,19 +481,107 @@
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
+struct CreateRecordContext
+{
+  struct GNUNET_NAMESTORE_RecordData *rd;
+  struct GNUNET_CRYPTO_RsaPrivateKey *pkey;
+  struct GNUNET_TIME_Absolute expire;
+  uint32_t op_id;
+  struct GNUNET_NAMESTORE_Client *nc;
+};
 
+struct GNUNET_CRYPTO_RsaSignature *
+GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey 
*key, struct GNUNET_NAMESTORE_RecordData *rd, unsigned int rd_count)
+{
+  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);
+  sig_purpose = GNUNET_malloc(sizeof (struct 
GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len);
+
+  sig_purpose->size = htonl (sizeof (struct 
GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len);
+  sig_purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
+  memcpy (&sig_purpose[1], rd_ser, rd_ser_len);
+
+  GNUNET_CRYPTO_rsa_sign (key, sig_purpose, sig);
+
+  GNUNET_free (rd_ser);
+  GNUNET_free (sig_purpose);
+  return sig;
+}
+
+static void
+handle_create_record_it (void *cls,
+    const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+    struct GNUNET_TIME_Absolute expire,
+    const char *name,
+    unsigned int rd_count,
+    const struct GNUNET_NAMESTORE_RecordData *rd,
+    const struct GNUNET_CRYPTO_RsaSignature *signature)
+{
+  struct CreateRecordContext * crc = cls;
+  struct GNUNET_CRYPTO_RsaSignature *signature_new;
+  struct RecordCreateResponseMessage rcr_msg;
+  int res;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u existing records for `%s'\n", 
rd_count, name);
+  struct GNUNET_NAMESTORE_RecordData *rd_new = GNUNET_malloc ((rd_count+1) * 
sizeof (struct GNUNET_NAMESTORE_RecordData));
+  memcpy (rd_new, rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+
+  rd_new[rd_count] = *(crc->rd);
+
+  signature_new = GNUNET_NAMESTORE_create_signature (crc->pkey, rd_new, 
rd_count+1);
+
+  /* Database operation */
+  res = GSN_database->put_records(GSN_database->cls,
+                                zone_key,
+                                expire,
+                                name,
+                                rd_count +1, rd_new,
+                                signature_new);
+
+  GNUNET_free (rd_new);
+  GNUNET_free (signature_new);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update result for name %u\n", res);
+  /* Send response */
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", 
"RECORD_CREATE_RESPONSE");
+  rcr_msg.header.type = htons 
(GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE_RESPONSE);
+  rcr_msg.op_id = htonl (crc->op_id);
+  rcr_msg.header.size = htons (sizeof (struct RecordCreateResponseMessage));
+  if (GNUNET_OK == res)
+    rcr_msg.op_result = htons (GNUNET_OK);
+  else
+    rcr_msg.op_result = htons (GNUNET_NO);
+  GNUNET_SERVER_notification_context_unicast (snc, crc->nc->client, (const 
struct GNUNET_MessageHeader *) &rcr_msg, GNUNET_NO);
+
+}
+
 static void handle_record_create (void *cls,
                           struct GNUNET_SERVER_Client * client,
                           const struct GNUNET_MessageHeader * message)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", 
"NAMESTORE_RECORD_CREATE");
   struct GNUNET_NAMESTORE_Client *nc;
-  struct RecordCreateResponseMessage rcr_msg;
+  struct GNUNET_NAMESTORE_RecordData *rd;
+  struct CreateRecordContext crc;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
+  GNUNET_HashCode pubkey_hash;
   size_t name_len;
   size_t msg_size;
   size_t msg_size_exp;
+  size_t rd_ser_len;
+  size_t key_len;
   uint32_t id = 0;
+  char *pkey_tmp;
+  char *name_tmp;
+  char *rd_ser;
+  int rd_count;
 
+
   int res = GNUNET_SYSERR;
 
   if (ntohs (message->size) < sizeof (struct RecordCreateMessage))
@@ -505,7 +603,9 @@
   id = ntohl (rp_msg->op_id);
   name_len = ntohs (rp_msg->name_len);
   msg_size = ntohs (message->size);
-  msg_size_exp = sizeof (struct RecordCreateMessage) + name_len + sizeof 
(struct GNUNET_NAMESTORE_RecordData);
+  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;
 
   if (msg_size != msg_size_exp)
   {
@@ -515,38 +615,49 @@
     return;
   }
 
-
   if ((name_len == 0) || (name_len > 256))
   {
     GNUNET_break_op (0);
     GNUNET_SERVER_receive_done (client, GNUNET_OK);
     return;
   }
-/*
-  if (name[name_len -1] != '\0')
+
+  pkey_tmp = (char *) &rp_msg[1];
+  name_tmp = &pkey_tmp[key_len];
+  rd_ser = &name_tmp[name_len];
+
+  if (name_tmp[name_len -1] != '\0')
   {
     GNUNET_break_op (0);
     GNUNET_SERVER_receive_done (client, GNUNET_OK);
     return;
   }
-*/
-  /* DO WORK HERE */
 
-  /* Send response */
+  rd_count = GNUNET_NAMESTORE_records_deserialize(&rd, rd_ser, rd_ser_len);
+  GNUNET_assert (rd_count == 1);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", 
"RECORD_CREATE_RESPONSE");
-  rcr_msg.header.type = htons 
(GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE_RESPONSE);
-  rcr_msg.op_id = rp_msg->op_id;
-  rcr_msg.header.size = htons (sizeof (struct RecordCreateResponseMessage));
-  if (GNUNET_OK == res)
-    rcr_msg.op_result = htons (GNUNET_OK);
-  else
-    rcr_msg.op_result = htons (GNUNET_NO);
-  GNUNET_SERVER_notification_context_unicast (snc, nc->client, (const struct 
GNUNET_MessageHeader *) &rcr_msg, GNUNET_NO);
+  /* Extracting and converting private key */
+  struct GNUNET_CRYPTO_RsaPrivateKey *pkey = 
GNUNET_CRYPTO_rsa_decode_key((char *) pkey_tmp, key_len);
+  GNUNET_assert (pkey != NULL);
+  GNUNET_CRYPTO_rsa_key_get_public(pkey, &pub);
+  GNUNET_CRYPTO_hash (&pub, sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &pubkey_hash);
 
+  crc.pkey = pkey;
+  crc.rd = rd;
+  crc.nc = nc;
+  crc.op_id = id;
+
+  /* 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);
 }
 
+
+
 static void handle_record_remove (void *cls,
                           struct GNUNET_SERVER_Client * client,
                           const struct GNUNET_MessageHeader * message)
@@ -712,7 +823,6 @@
   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 */

Modified: gnunet/src/namestore/namestore.h
===================================================================
--- gnunet/src/namestore/namestore.h    2012-02-29 19:21:20 UTC (rev 20150)
+++ gnunet/src/namestore/namestore.h    2012-02-29 19:21:45 UTC (rev 20151)
@@ -171,7 +171,7 @@
   uint16_t contains_sig;
 
   /* Requested record type */
-  uint32_t rd_len;
+  uint16_t rd_len;
 };
 GNUNET_NETWORK_STRUCT_END
 
@@ -202,6 +202,9 @@
   /* Length of serialized rd data */
   uint16_t rd_len;
 
+  /* Length of pubkey */
+  uint16_t key_len;
+
   struct GNUNET_TIME_AbsoluteNBO expire;
 
   struct GNUNET_CRYPTO_RsaSignature signature;
@@ -235,9 +238,9 @@
 
 
 /**
- * Put a record to the namestore
+ * Create a record and put it to the namestore
  * Memory layout:
- * [struct RecordPutMessage][struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded][char *name][rc_count * struct 
GNUNET_NAMESTORE_RecordData]
+ * [struct RecordCreateMessage][char *name][rc_count * struct 
GNUNET_NAMESTORE_RecordData]
  */
 GNUNET_NETWORK_STRUCT_BEGIN
 struct RecordCreateMessage
@@ -257,7 +260,11 @@
   /* name length */
   uint16_t name_len;
 
-  struct GNUNET_CRYPTO_RsaSignature signature;
+  /* Record data length */
+  uint16_t rd_len;
+
+  /* private key length */
+  uint16_t pkey_len;
 };
 GNUNET_NETWORK_STRUCT_END
 
@@ -285,6 +292,8 @@
    *  name length: GNUNET_NO (0) on error, GNUNET_OK (1) on success
    */
   uint16_t op_result;
+
+
 };
 GNUNET_NETWORK_STRUCT_END
 

Modified: gnunet/src/namestore/namestore_api.c
===================================================================
--- gnunet/src/namestore/namestore_api.c        2012-02-29 19:21:20 UTC (rev 
20150)
+++ gnunet/src/namestore/namestore_api.c        2012-02-29 19:21:45 UTC (rev 
20151)
@@ -27,10 +27,18 @@
 
 #include "platform.h"
 #include "gnunet_util_lib.h"
+#include "gnunet_crypto_lib.h"
 #include "gnunet_constants.h"
 #include "gnunet_arm_service.h"
 #include "gnunet_namestore_service.h"
 #include "namestore.h"
+
+#include "platform.h"
+#include <gcrypt.h>
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+
 #define DEBUG_GNS_API GNUNET_EXTRA_LOGGING
 
 #define LOG(kind,...) GNUNET_log_from (kind, "gns-api",__VA_ARGS__)
@@ -212,7 +220,7 @@
   int contains_sig = GNUNET_NO;
   int rd_count = 0;
 
-  rd_len = ntohl (msg->rd_len);
+  rd_len = ntohs (msg->rd_len);
   msg_len = ntohs (msg->header.size);
   name_len = ntohs (msg->name_len);
   contains_sig = ntohs (msg->contains_sig);
@@ -749,7 +757,7 @@
   struct PendingMessage *pe;
 
   /* pointer to elements */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key_tmp;
+  char * zone_key_tmp;
   char * rd_tmp;
   char * rd_ser;
   char * name_tmp;
@@ -757,6 +765,7 @@
   size_t msg_size = 0;
   size_t name_len = 0;
   size_t rd_ser_len = 0;
+  size_t pubkey_len = 0;
   uint32_t id = 0;
 
   GNUNET_assert (NULL != h);
@@ -782,29 +791,31 @@
 
   /* set msg_size*/
   rd_ser_len = GNUNET_NAMESTORE_records_serialize(&rd_ser, rd_count, rd);
-
+  pubkey_len = sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);
   struct RecordPutMessage * msg;
-  msg_size = sizeof (struct RecordPutMessage) + sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + name_len  + rd_ser_len;
+  msg_size = sizeof (struct RecordPutMessage) + pubkey_len + name_len  + 
rd_ser_len;
 
   /* create msg here */
   pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
   pe->size = msg_size;
   pe->is_init = GNUNET_NO;
   msg = (struct RecordPutMessage *) &pe[1];
-  zone_key_tmp = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &msg[1];
-  name_tmp = (char *) &zone_key_tmp[1];
+  zone_key_tmp = (char *) &msg[1];
+  name_tmp = (char *) &zone_key_tmp[pubkey_len];
   rd_tmp = &name_tmp[name_len];
 
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_PUT);
   msg->header.size = htons (msg_size);
   msg->op_id = htonl (id);
-  memcpy (zone_key_tmp, zone_key, sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+  msg->key_len = htons (pubkey_len);
+  memcpy (zone_key_tmp, zone_key, pubkey_len);
   msg->signature = *signature;
   msg->name_len = htons (name_len);
   memcpy (name_tmp, name, name_len);
   msg->expire = GNUNET_TIME_absolute_hton (expire);
   msg->rd_len = htons (rd_ser_len);
 
+
   memcpy (rd_tmp, rd_ser, rd_ser_len);
   GNUNET_free (rd_ser);
 
@@ -862,26 +873,42 @@
   struct GNUNET_NAMESTORE_QueueEntry *qe;
   struct PendingMessage *pe;
   char * name_tmp;
+  char * pkey_tmp;
   char * rd_tmp;
   char * rd_ser;
   size_t rd_ser_len = 0;
   size_t msg_size = 0;
   size_t name_len = 0;
+  size_t key_len = 0;
   uint32_t id = 0;
 
   GNUNET_assert (NULL != h);
+  GNUNET_assert (NULL != pkey);
+  GNUNET_assert (NULL != name);
+  GNUNET_assert (NULL != rd);
 
+  name_len = strlen(name) + 1;
+  if (name_len > 256)
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+
   id = get_op_id(h);
   qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
   qe->nsh = h;
   qe->cont = cont;
   qe->cont_cls = cont_cls;
   qe->op_id = id;
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
 
   /* set msg_size*/
+  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded * pkey_enc = 
GNUNET_CRYPTO_rsa_encode_key (pkey);
+  GNUNET_assert (pkey_enc != NULL);
+  key_len = ntohs (pkey_enc->len);
   rd_ser_len = GNUNET_NAMESTORE_records_serialize(&rd_ser, 1, rd);
   struct RecordCreateMessage * msg;
-  msg_size = sizeof (struct RecordCreateMessage) + name_len + rd_ser_len;
+  msg_size = sizeof (struct RecordCreateMessage) + key_len + name_len + 
rd_ser_len;
 
   /* create msg here */
   pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
@@ -889,17 +916,21 @@
   pe->is_init = GNUNET_NO;
   msg = (struct RecordCreateMessage *) &pe[1];
 
-  name_tmp = (char *) &msg[1];
+  pkey_tmp = (char *) &msg[1];
+  name_tmp = &pkey_tmp[key_len];
   rd_tmp = &name_tmp[name_len];
 
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE);
   msg->header.size = htons (msg_size);
   msg->op_id = htonl (id);
-  //msg->signature = *signature;
   msg->name_len = htons (name_len);
+  msg->rd_len = htons (rd_ser_len);
+  msg->pkey_len = htons (key_len);
+  memcpy (pkey_tmp, pkey_enc, key_len);
   memcpy (name_tmp, name, name_len);
   memcpy (rd_tmp, rd_ser, rd_ser_len);
   GNUNET_free (rd_ser);
+  GNUNET_free (pkey_enc);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s' 
with size %u\n", "NAMESTORE_RECORD_CREATE", name, msg_size);
 

Modified: gnunet/src/namestore/test_namestore_api_put.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_put.c       2012-02-29 19:21:20 UTC 
(rev 20150)
+++ gnunet/src/namestore/test_namestore_api_put.c       2012-02-29 19:21:45 UTC 
(rev 20151)
@@ -41,7 +41,6 @@
 
 static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
-static GNUNET_HashCode zone;
 
 struct GNUNET_NAMESTORE_RecordData *rd;
 
@@ -163,9 +162,6 @@
   /* get public key */
   GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
 
-  /* create random zone hash */
-  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &zone);
-
   struct GNUNET_CRYPTO_RsaSignature signature;
 
   start_arm (cfgfile);

Modified: gnunet/src/namestore/test_namestore_record_serialization.c
===================================================================
--- gnunet/src/namestore/test_namestore_record_serialization.c  2012-02-29 
19:21:20 UTC (rev 20150)
+++ gnunet/src/namestore/test_namestore_record_serialization.c  2012-02-29 
19:21:45 UTC (rev 20151)
@@ -36,10 +36,10 @@
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  char * dest = NULL;
+  char * rd_ser = NULL;
   size_t len;
   int c;
-  int elem = 0;
+  int dst_elem = 0;
 
   int rd_count = 3;
   size_t data_len;
@@ -61,18 +61,18 @@
   }
   res = 0;
 
-  len = GNUNET_NAMESTORE_records_serialize (&dest, rd_count, src);
+  len = GNUNET_NAMESTORE_records_serialize (&rd_ser, rd_count, src);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Serialized data len: %u\n",len);
 
-  GNUNET_assert (dest != NULL);
+  GNUNET_assert (rd_ser != NULL);
 
-  elem = GNUNET_NAMESTORE_records_deserialize(&dst, dest, len);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deserialized elements: %u\n",elem);
+  dst_elem = GNUNET_NAMESTORE_records_deserialize(&dst, rd_ser, len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deserialized elements: %u\n",dst_elem);
 
-  GNUNET_assert (elem == rd_count);
+  GNUNET_assert (dst_elem == rd_count);
   GNUNET_assert (dst != NULL);
 
-  for (c = 0; c < elem; c++)
+  for (c = 0; c < dst_elem; c++)
   {
     if (src[c].data_size != dst[c].data_size)
     {
@@ -115,12 +115,12 @@
     }
 
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Element [%i]: EQUAL\n", c);
-    /* clean up */
-    GNUNET_free((char *) dst[c].data);
-    GNUNET_free((char *) src[c].data);
   }
-  GNUNET_free (dest);
-  GNUNET_free (dst);
+
+  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