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

[gnunet]

Author: wachs
Date: 2012-03-02 11:12:57 +0100 (Fri, 02 Mar 2012)
New Revision: 20189

Modified:
   gnunet/src/namestore/gnunet-service-namestore.c
   gnunet/src/namestore/test_namestore_api.conf
   gnunet/src/namestore/test_namestore_api_create.c
Log:
- fixes


Modified: gnunet/src/namestore/gnunet-service-namestore.c
===================================================================
--- gnunet/src/namestore/gnunet-service-namestore.c     2012-03-02 09:36:29 UTC 
(rev 20188)
+++ gnunet/src/namestore/gnunet-service-namestore.c     2012-03-02 10:12:57 UTC 
(rev 20189)
@@ -191,6 +191,8 @@
   struct GNUNET_NAMESTORE_Client *nc;
   uint32_t request_id;
   uint32_t record_type;
+  GNUNET_HashCode *zone;
+  char * name;
 };
 
 
@@ -216,8 +218,8 @@
   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");
 
+
   size_t r_size = 0;
 
   size_t name_len = 0;
@@ -269,6 +271,8 @@
   char rd_ser[rd_ser_len];
   GNUNET_NAMESTORE_records_serialize(copied_elements, rd_selected, rd_ser_len, 
rd_ser);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u records for name `%s' in zone 
`%s'\n",
+      copied_elements, lnc->name, GNUNET_h2s(lnc->zone));
 
   if ((copied_elements == rd_count) && (signature != NULL))
       contains_signature = GNUNET_YES;
@@ -282,6 +286,8 @@
            rd_ser_len +
            contains_signature * sizeof (struct GNUNET_CRYPTO_RsaSignature);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", 
"NAMESTORE_LOOKUP_NAME_RESPONSE");
+
   lnr_msg = GNUNET_malloc (r_size);
 
   lnr_msg->gns_header.header.type = ntohs 
(GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE);
@@ -370,6 +376,8 @@
   lnc.request_id = rid;
   lnc.nc = nc;
   lnc.record_type = type;
+  lnc.name = name;
+  lnc.zone = &ln_msg->zone;
   res = GSN_database->iterate_records(GSN_database->cls, &ln_msg->zone, name, 
0, &handle_lookup_name_it, &lnc);
 
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -507,13 +515,16 @@
 {
   struct GNUNET_NAMESTORE_RecordData *rd;
   struct GNUNET_CRYPTO_RsaPrivateKey *pkey;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey;
   struct GNUNET_TIME_Absolute expire;
+  char *name;
+  int res;
 };
 
 
 static void
 handle_create_record_it (void *cls,
-    const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+    const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey,
     struct GNUNET_TIME_Absolute expire,
     const char *name,
     unsigned int rd_count,
@@ -524,26 +535,33 @@
   struct GNUNET_CRYPTO_RsaSignature *signature_new;
   int res;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u existing records for `%s'\n", 
rd_count, name);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u existing records for `%s'\n", 
rd_count, crc->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, name, rd_new, 
rd_count+1);
+  signature_new = GNUNET_NAMESTORE_create_signature (crc->pkey, crc->name, 
rd_new, rd_count+1);
+  if (NULL == signature_new)
+  {
+    GNUNET_break (0);
+    res = GNUNET_SYSERR;
+  }
 
   /* Database operation */
   res = GSN_database->put_records(GSN_database->cls,
-                                zone_key,
-                                expire,
-                                name,
+                                (const struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) crc->pubkey,
+                                crc->expire,
+                                crc->name,
                                 rd_count +1, rd_new,
                                 signature_new);
+  GNUNET_break (GNUNET_OK == res);
 
   GNUNET_free (rd_new);
   GNUNET_free (signature_new);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update result for name %u\n", res);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update result for name `%s' %s\n", 
crc->name, (res == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  crc->res = res;
 }
 
 static void handle_record_create (void *cls,
@@ -622,12 +640,11 @@
 
   struct GNUNET_NAMESTORE_RecordData rd[rd_count];
   res = GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd);
-  if (res != GNUNET_OK)
+  if ((res != GNUNET_OK) || (rd_count != 1))
   {
     GNUNET_break_op (0);
     goto send;
   }
-  GNUNET_assert (rd_count == 1);
 
   /* Extracting and converting private key */
   pkey = GNUNET_CRYPTO_rsa_decode_key((char *) pkey_tmp, key_len);
@@ -636,13 +653,16 @@
   GNUNET_CRYPTO_hash (&pub, sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &pubkey_hash);
 
   crc.pkey = pkey;
+  crc.pubkey = &pub;
   crc.rd = rd;
+  crc.name = name_tmp;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating record for name `%s' in zone 
`%s'\n", name_tmp, GNUNET_h2s(&pubkey_hash));
 
   /* Get existing records for name */
   res = GSN_database->iterate_records(GSN_database->cls, &pubkey_hash, 
name_tmp, 0, &handle_create_record_it, &crc);
-
+  if (res != GNUNET_SYSERR)
+    res = GNUNET_OK;
   GNUNET_CRYPTO_rsa_key_free(pkey);
 
   /* Send response */
@@ -651,7 +671,7 @@
   rcr_msg.gns_header.header.type = htons 
(GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE_RESPONSE);
   rcr_msg.gns_header.r_id = htonl (rid);
   rcr_msg.gns_header.header.size = htons (sizeof (struct 
RecordCreateResponseMessage));
-  if (GNUNET_OK == res)
+  if ((GNUNET_OK == res) && (crc.res == GNUNET_OK))
     rcr_msg.op_result = htons (GNUNET_OK);
   else
     rcr_msg.op_result = htons (GNUNET_NO);
@@ -853,8 +873,12 @@
   GNUNET_CRYPTO_hash (&pub, sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &pubkey_hash);
 
   struct GNUNET_NAMESTORE_RecordData rd[rd_count];
-  GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd);
-  GNUNET_assert (rd_count == 1);
+  res = GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd);
+  if ((res != GNUNET_OK) || (rd_count != 1))
+  {
+    GNUNET_break_op (0);
+    goto send;
+  }
 
   struct RemoveRecordContext rrc;
   rrc.rd = rd;
@@ -871,13 +895,15 @@
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing record for name `%s': %s\n",
       name_tmp, (rrc.op_res == 0) ? "OK" : "FAIL");
+  res = rrc.op_res;
 
   /* Send response */
+send:
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", 
"RECORD_REMOVE_RESPONSE");
   rrr_msg.gns_header.header.type = htons 
(GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE_RESPONSE);
   rrr_msg.gns_header.r_id = rr_msg->gns_header.r_id;
   rrr_msg.gns_header.header.size = htons (sizeof (struct 
RecordRemoveResponseMessage));
-  rrr_msg.op_result = htons (rrc.op_res);
+  rrr_msg.op_result = htons (res);
   GNUNET_SERVER_notification_context_unicast (snc, nc->client, (const struct 
GNUNET_MessageHeader *) &rrr_msg, GNUNET_NO);
 
   GNUNET_CRYPTO_rsa_key_free (pkey);

Modified: gnunet/src/namestore/test_namestore_api.conf
===================================================================
--- gnunet/src/namestore/test_namestore_api.conf        2012-03-02 09:36:29 UTC 
(rev 20188)
+++ gnunet/src/namestore/test_namestore_api.conf        2012-03-02 10:12:57 UTC 
(rev 20189)
@@ -19,7 +19,7 @@
 DATABASE = sqlite
 
 [namestore-sqlite]
-FILENAME = $SERVICEHOME/namestore/sqlite.db
+FILENAME = $SERVICEHOME/namestore/sqlite_test.db
 
 [namestore-postgres]
 CONFIG = connect_timeout=10; dbname=gnunet

Modified: gnunet/src/namestore/test_namestore_api_create.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_create.c    2012-03-02 09:36:29 UTC 
(rev 20188)
+++ gnunet/src/namestore/test_namestore_api_create.c    2012-03-02 10:12:57 UTC 
(rev 20189)
@@ -29,7 +29,7 @@
 
 #define VERBOSE GNUNET_NO
 
-#define RECORDS 5
+#define RECORDS 1
 #define TEST_RECORD_TYPE 1234
 #define TEST_RECORD_DATALEN 123
 #define TEST_RECORD_DATA 'a'
@@ -121,7 +121,7 @@
   for (c = 0; c < RECORDS; c++)
     GNUNET_free_non_null((void *) s_rd[c].data);
   GNUNET_free (s_rd);
-  GNUNET_free (s_create_rd);
+  //GNUNET_free (s_create_rd);
 
   if (privkey != NULL)
     GNUNET_CRYPTO_rsa_key_free (privkey);
@@ -162,7 +162,7 @@
       failed = GNUNET_YES;
     }
 
-    if (RECORDS+1 != rd_count)
+    if (RECORDS != rd_count)
     {
       GNUNET_break (0);
       failed = GNUNET_YES;
@@ -176,48 +176,17 @@
       GNUNET_break (0 == memcmp (rd[c].data, s_rd[c].data, 
TEST_RECORD_DATALEN));
     }
 
-    if (rd[c].record_type != TEST_CREATE_RECORD_TYPE)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "record_type %u %u\n", 
rd[c].record_type , TEST_CREATE_RECORD_TYPE);
-      GNUNET_break (0);
-      failed = GNUNET_YES;
-    }
-    if (rd[c].data_size != TEST_CREATE_RECORD_DATALEN)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "data_size %u %u\n", 
rd[c].data_size , TEST_CREATE_RECORD_DATALEN);
-      GNUNET_break (0);
-      failed = GNUNET_YES;
-    }
-    else
-    {
-      char *dummy[TEST_CREATE_RECORD_DATALEN];
-      memset (&dummy, TEST_CREATE_RECORD_DATA, TEST_CREATE_RECORD_DATALEN);
-      if (0 != memcmp (&dummy, s_create_rd->data, TEST_CREATE_RECORD_DATALEN))
-      {
-        GNUNET_break (0);
-        failed = GNUNET_YES;
-      }
-    }
-
     if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature(&pubkey, n, rd_count, 
rd, signature))
     {
       GNUNET_break (0);
       failed = GNUNET_YES;
     }
 
-    struct GNUNET_NAMESTORE_RecordData rd_new[RECORDS +1];
-    int c2;
-    for (c2 = 0; c2 < RECORDS; c2++)
-      rd_new[c2] = s_rd[c2];
-    rd_new[c2] = *s_create_rd;
-    s_signature_updated = GNUNET_NAMESTORE_create_signature(privkey, n, 
rd_new, RECORDS +1);
-
-    if (0 != memcmp (s_signature_updated, signature, sizeof (struct 
GNUNET_CRYPTO_RsaSignature)))
+    if (0 != memcmp (s_signature, signature, sizeof (struct 
GNUNET_CRYPTO_RsaSignature)))
     {
       GNUNET_break (0);
       failed = GNUNET_YES;
     }
-    GNUNET_free (s_signature_updated);
 
     found = GNUNET_YES;
     if (failed == GNUNET_NO)
@@ -245,7 +214,6 @@
   if (success == GNUNET_OK)
   {
     res = 0;
-
     GNUNET_NAMESTORE_lookup_record (nsh, &s_zone, name, 0, &name_lookup_proc, 
name);
   }
   else
@@ -290,7 +258,7 @@
   struct GNUNET_NAMESTORE_RecordData * rd;
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
 
-  for (c = 0; c < RECORDS; c++)
+  for (c = 0; c < count; c++)
   {
   rd[c].expiration = GNUNET_TIME_absolute_get();
   rd[c].record_type = TEST_RECORD_TYPE;
@@ -302,10 +270,30 @@
   return rd;
 }
 
+void
+delete_existing_db (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  char *afsdir;
+
+  if (GNUNET_OK ==
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "namestore-sqlite",
+                                               "FILENAME", &afsdir))
+  {
+    if (GNUNET_OK == GNUNET_DISK_file_test (afsdir))
+      if (GNUNET_OK == GNUNET_DISK_file_test (afsdir))
+        if (GNUNET_OK == GNUNET_DISK_directory_remove(afsdir))
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleted existing database `%s' 
\n", afsdir);
+   GNUNET_free (afsdir);
+  }
+
+}
+
 static void
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
+  delete_existing_db(cfg);
+
   endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,endbadly, NULL);
   size_t rd_ser_len;
 
@@ -317,37 +305,30 @@
 
   /* create record */
   s_name = "dummy.dummy.gnunet";
-  s_rd = create_record (RECORDS);
+  s_rd = create_record (1);
 
-  rd_ser_len = GNUNET_NAMESTORE_records_get_size(RECORDS, s_rd);
+  rd_ser_len = GNUNET_NAMESTORE_records_get_size(1, s_rd);
   char rd_ser[rd_ser_len];
-  GNUNET_NAMESTORE_records_serialize(RECORDS, s_rd, rd_ser_len, rd_ser);
+  GNUNET_NAMESTORE_records_serialize(1, s_rd, rd_ser_len, rd_ser);
 
-  s_signature = GNUNET_NAMESTORE_create_signature(privkey, s_name, s_rd, 
RECORDS);
+  s_signature = GNUNET_NAMESTORE_create_signature(privkey, s_name, s_rd, 1);
 
   /* create random zone hash */
   GNUNET_CRYPTO_hash (&pubkey, sizeof (struct 
GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name: `%s' Zone: `%s' \n", s_name, 
GNUNET_h2s_full(&s_zone));
 
-
   start_arm (cfgfile);
   GNUNET_assert (arm != NULL);
 
   nsh = GNUNET_NAMESTORE_connect (cfg);
   GNUNET_break (NULL != nsh);
 
-
-
   GNUNET_break (s_rd != NULL);
   GNUNET_break (s_name != NULL);
 
-  GNUNET_NAMESTORE_record_put (nsh, &pubkey, s_name,
-                              GNUNET_TIME_absolute_get_forever(),
-                              RECORDS, s_rd, s_signature, put_cont, s_name);
-
-
-
+  /* create initial record */
+  GNUNET_NAMESTORE_record_create (nsh, privkey, s_name, s_rd, &create_cont, 
s_name);
 }
 
 static int