-integrated block plugin

diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c
index 6f3cb9900ff656f5f3c59fdf3cacbfee6c35277b..101acb5a96b9508d5e04eaf2933a4ee5e18062c0 100644 (file)
--- a/src/gns/gnunet-service-gns.c
+++ b/src/gns/gnunet-service-gns.c
@@ -257,7 +257,7 @@ process_authority_dht_result(void* cls,
       rh->answered = 1;
       GNUNET_CRYPTO_hash(
                  (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *)rd[i].data,
-                 GNUNET_CRYPTO_RSA_KEY_LENGTH,
+                 rd[i].data_size,
                  &rh->authority);
     }
     rb = (struct GNSRecordBlock*)((char*)&rb[1] + rd[i].data_size);
@@ -314,7 +314,7 @@ resolve_authority_dht(struct GNUNET_GNS_ResolverHandle *rh, const char* name)
   xquery = htonl(GNUNET_GNS_RECORD_PKEY);
   //FIXME how long to wait for results?
   rh->get_handle = GNUNET_DHT_get_start(dht_handle, timeout,
-                       GNUNET_BLOCK_TYPE_TEST, //FIXME todo
+                       GNUNET_BLOCK_TYPE_GNS_NAMERECORD, //FIXME todo
                        &lookup_key,
                        5, //Replication level FIXME
                        GNUNET_DHT_RO_NONE,
@@ -454,7 +454,7 @@ resolve_name_dht(struct GNUNET_GNS_ResolverHandle *rh, const char* name)
   xquery = htonl(rh->query->type);
   //FIXME how long to wait for results?
   rh->get_handle = GNUNET_DHT_get_start(dht_handle, timeout,
-                       GNUNET_BLOCK_TYPE_TEST, //FIXME todo
+                       GNUNET_BLOCK_TYPE_GNS_NAMERECORD, //FIXME todo
                        &lookup_key,
                        5, //Replication level FIXME
                        GNUNET_DHT_RO_NONE,
@@ -496,7 +496,7 @@ process_authority_lookup(void* cls,
   GNUNET_HashCode zone;
 
   rh = (struct GNUNET_GNS_ResolverHandle *)cls;
-  GNUNET_CRYPTO_hash(key, GNUNET_CRYPTO_RSA_KEY_LENGTH, &zone);
+  GNUNET_CRYPTO_hash(key, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone);
   remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
   
   /**
@@ -548,7 +548,7 @@ process_authority_lookup(void* cls,
       }
 
       GNUNET_assert(rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
-      GNUNET_CRYPTO_hash(rd[i].data, GNUNET_CRYPTO_RSA_KEY_LENGTH,
+      GNUNET_CRYPTO_hash(rd[i].data, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
                          &rh->authority);
       resolve_name(rh);
       return;
@@ -688,7 +688,7 @@ process_authoritative_result(void* cls,
   GNUNET_HashCode zone;
 
   rh = (struct GNUNET_GNS_ResolverHandle *) cls;
-  GNUNET_CRYPTO_hash(key, GNUNET_CRYPTO_RSA_KEY_LENGTH, &zone);
+  GNUNET_CRYPTO_hash(key, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone);
   remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
 
   //FIXME Handle results in rd
@@ -1107,11 +1107,21 @@ put_gns_record(void *cls,
   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
              "putting records for %s under key: %s with size %d\n",
              name, (char*)&xor_hash_string, rd_payload_length);
+  GNUNET_CRYPTO_hash_to_enc (&zone_hash, &xor_hash_string);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Pub key: %s\n", (char*)&xor_hash_string);
+  GNUNET_CRYPTO_hash_to_enc (&name_hash, &xor_hash_string);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Name: %s\n", (char*)&xor_hash_string);
+
+  GNUNET_HashCode key_hash;
+  GNUNET_CRYPTO_hash(key, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     &key_hash);
+  GNUNET_CRYPTO_hash_to_enc (&key_hash, &xor_hash_string);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Pub2: %s\n", (char*)&xor_hash_string);
 
   GNUNET_DHT_put (dht_handle, &xor_hash,
                   5, //replication level
                   GNUNET_DHT_RO_NONE,
-                  GNUNET_BLOCK_TYPE_TEST, //FIXME todo block plugin
+                  GNUNET_BLOCK_TYPE_GNS_NAMERECORD, //FIXME todo block plugin
                   rd_payload_length,
                   (char*)nrb,
                   expiration,
@@ -1216,7 +1226,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   GNUNET_CRYPTO_rsa_key_get_public (zone_key, &pkey);
   //zone_key = GNUNET_CRYPTO_rsa_key_create ();
 
-  GNUNET_CRYPTO_hash(&pkey, GNUNET_CRYPTO_RSA_KEY_LENGTH,
+  GNUNET_CRYPTO_hash(&pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
                      &zone_hash);
   
   nc = GNUNET_SERVER_notification_context_create (server, 1);

diff --git a/src/gns/namestore_stub_api.c b/src/gns/namestore_stub_api.c
index b1fd7768312aa96ad80d6542789a6e79555e0cee..c61aa6f0ad26cadca93d50e123bb6714d73cf0dc 100644 (file)
--- a/src/gns/namestore_stub_api.c
+++ b/src/gns/namestore_stub_api.c
@@ -249,12 +249,14 @@ GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
 
   zone_hash = GNUNET_malloc(sizeof(GNUNET_HashCode));
 
-  GNUNET_CRYPTO_hash(pkey, GNUNET_CRYPTO_RSA_KEY_LENGTH, zone_hash);
+  GNUNET_CRYPTO_hash(pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     zone_hash);
   
   sr = h->records_head;
   for (; sr != NULL; sr = sr->next)
   {
-    if (strcmp(sr->name, name) && (sr->zone == zone_hash))
+    if ((strcmp(sr->name, name) == 0) &&
+        (0 == GNUNET_CRYPTO_hash_cmp(sr->zone, zone_hash)))
     {
       //Dangerous
       memcpy (&(sr->rd[sr->rd_count-1]), rd,

diff --git a/src/gns/plugin_block_gns.c b/src/gns/plugin_block_gns.c
index aa37ec6da056c4e208f4439ba4272715ffe26f83..e941876d22b6449c54b003166db2f6953cca2017 100644 (file)
--- a/src/gns/plugin_block_gns.c
+++ b/src/gns/plugin_block_gns.c
@@ -36,9 +36,6 @@
  */
 #define BLOOMFILTER_K 16
 
-//Not taken until now
-#define GNUNET_BLOCK_TYPE_GNS_NAMERECORD 11
-
 /**
  * Function called to validate a reply or a request.  For
  * request evaluation, simply pass "NULL" for the reply_block.
@@ -67,39 +64,50 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
 {
   if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
     return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
+  if (reply_block_size == 0)
+    return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
   
   char* name;
   GNUNET_HashCode pkey_hash;
-  GNUNET_HashCode query_pkey;
+  GNUNET_HashCode query_key;
   GNUNET_HashCode name_hash;
   GNUNET_HashCode mhash;
   GNUNET_HashCode chash;
   struct GNSNameRecordBlock *nrb;
   struct GNSRecordBlock *rb;
   uint32_t rd_count;
-
+  
   nrb = (struct GNSNameRecordBlock *)reply_block;
-
   name = (char*)&nrb[1];
-
   GNUNET_CRYPTO_hash(&nrb->public_key,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                     sizeof(nrb->public_key),
                      &pkey_hash);
 
   GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
 
-  GNUNET_CRYPTO_hash_xor(query, &name_hash, &query_pkey);
+  GNUNET_CRYPTO_hash_xor(&pkey_hash, &name_hash, &query_key);
+  struct GNUNET_CRYPTO_HashAsciiEncoded hstr;
+  GNUNET_CRYPTO_hash_to_enc (query, &hstr);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Query key: %s\n", (char*)&hstr);
+  GNUNET_CRYPTO_hash_to_enc (&pkey_hash, &hstr);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Pub key: %s\n", (char*)&hstr);
+  GNUNET_CRYPTO_hash_to_enc (&name_hash, &hstr);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Name: %s\n", (char*)&hstr);
+  GNUNET_CRYPTO_hash_to_enc (&query_key, &hstr);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "XOR: %s\n", (char*)&hstr);
+  
   
   //Check query key against public key
-  if (0 != GNUNET_CRYPTO_hash_cmp(&query_pkey, &pkey_hash))
+  if (0 != GNUNET_CRYPTO_hash_cmp(query, &query_key))
     return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-
+  
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Checking payload\n");
   rd_count = ntohl(nrb->rd_count);
 
   struct GNUNET_NAMESTORE_RecordData rd[rd_count];
   int i = 0;
   int record_match = 0;
-  rb = (struct GNSRecordBlock*)(&nrb[1] + strlen(name) + 1);
+  rb = (struct GNSRecordBlock*)(&name[strlen(name) + 1]);
 
   for (i=0; i<rd_count; i++)
   {
@@ -109,25 +117,27 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
     rd[i].data_size = ntohl(rb->data_length);
     rd[i].flags = ntohl(rb->flags);
     rd[i].data = (char*)&rb[1];
-    rb = &rb[1] + rd[i].data_size;
+    rb = (struct GNSRecordBlock *)((char*)&rb[1] + rd[i].data_size);
     if (xquery_size > 0 && (rd[i].record_type == *((uint32_t*)xquery)))
       record_match++;
   }
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "done\n");
   
-  //No record matches query
-  if (xquery_size > 0 && (record_match == 0))
-    return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
 
-  if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (&nrb->public_key,
+  /*if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (&nrb->public_key,
                                                       name,
-                                                      nrb->rd_count,
+                                                      rd_count,
                                                       rd,
-                                                      &nrb->signature))
+                                                      NULL))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Signature invalid\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Signature invalid\n");
     return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-  }
-
+  }*/
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "done\n");
+  //No record matches query
+  if ((xquery_size > 0) && (record_match == 0))
+    return GNUNET_BLOCK_EVALUATION_OK_MORE;
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Records match\n");
   //FIXME do bf check before or after crypto??
   if (NULL != bf)
   {
@@ -135,6 +145,7 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
     GNUNET_BLOCK_mingle_hash(&chash, bf_mutator, &mhash);
     if (NULL != *bf)
     {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Check BF\n");
       if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test(*bf, &mhash))
         return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
     }
@@ -144,8 +155,8 @@ block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
     }
     GNUNET_CONTAINER_bloomfilter_add(*bf, &mhash);
   }
-
-  return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "No dup\n");
+  return GNUNET_BLOCK_EVALUATION_OK_MORE;
 }
 
 
@@ -166,7 +177,7 @@ block_plugin_gns_get_key (void *cls, enum GNUNET_BLOCK_Type type,
                          GNUNET_HashCode * key)
 {
   if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
-    return GNUNET_NO;
+    return GNUNET_SYSERR;
   GNUNET_HashCode name_hash;
   GNUNET_HashCode pkey_hash;
   struct GNSNameRecordBlock *nrb = (struct GNSNameRecordBlock *)block;

diff --git a/src/gns/test_gns_twopeer.conf b/src/gns/test_gns_twopeer.conf
index 16d8b3ab71ce15c802fafb4b526bbcb0ffad544e..40482975b1b73c80347059569c150982b13f87d9 100644 (file)
--- a/src/gns/test_gns_twopeer.conf
+++ b/src/gns/test_gns_twopeer.conf
@@ -14,7 +14,7 @@ PORT = 2100
 BINARY = gnunet-service-dht
 
 [block]
-plugins = dht test
+plugins = dht test gns
 
 [dhtcache]
 QUOTA = 1 MB