use block lib some more

diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 2c9d41b05603b5db274d32a7c925ed5d470b2d3b..0b06173409b981025fc60d5d0ea6d9aa2bdec320 100644 (file)
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -1639,6 +1639,7 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
   char *kbe;
   char *sptr;
 
+  GNUNET_assert (NULL != uri);
   pkc = GNUNET_malloc (sizeof (struct PublishKskContext));
   pkc->h = h;
   pkc->expirationTime = expirationTime;

diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index a0e275f2de6c35df8e5b2503f8afc929ec0dfddd..72d89c7267f5eea54c03f38b415aa083a82bdf49 100644 (file)
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -1786,23 +1786,6 @@ add_to_pending_messages_for_peer (struct ConnectedPeer *cp,
 }
 
 
-/**
- * Mingle hash with the mingle_number to produce different bits.
- */
-static void
-mingle_hash (const GNUNET_HashCode * in,
-            int32_t mingle_number, 
-            GNUNET_HashCode * hc)
-{
-  GNUNET_HashCode m;
-
-  GNUNET_CRYPTO_hash (&mingle_number, 
-                     sizeof (int32_t), 
-                     &m);
-  GNUNET_CRYPTO_hash_xor (&m, in, hc);
-}
-
-
 /**
  * Test if the load on this peer is too high
  * to even consider processing the query at
@@ -1965,7 +1948,9 @@ refresh_bloomfilter (struct PendingRequest *pr)
                                              BLOOMFILTER_K);
   for (i=0;i<pr->replies_seen_off;i++)
     {
-      mingle_hash (&pr->replies_seen[i], pr->mingle, &mhash);
+      GNUNET_BLOCK_mingle_hash (&pr->replies_seen[i],
+                               pr->mingle,
+                               &mhash);
       GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
     }
 }
@@ -2534,8 +2519,7 @@ process_reply (void *cls,
   struct PutMessage *pm;
   struct ConnectedPeer *cp;
   struct GNUNET_TIME_Relative cur_delay;
-  GNUNET_HashCode chash;
-  GNUNET_HashCode mhash;
+  enum GNUNET_BLOCK_EvaluationResult eval;
   size_t msize;
 
 #if DEBUG_FS
@@ -2581,9 +2565,6 @@ process_reply (void *cls,
          GNUNET_SERVER_client_keep (pr->client_request_list->client_list->client);
        }
     }
-  GNUNET_CRYPTO_hash (prq->data,
-                     prq->size,
-                     &chash);
   switch (prq->type)
     {
     case GNUNET_BLOCK_TYPE_DBLOCK:
@@ -2617,39 +2598,96 @@ process_reply (void *cls,
          GNUNET_break (0);
          return GNUNET_YES;
        }
-      if (0 != memcmp (pr->namespace,
-                      &prq->namespace,
-                      sizeof (GNUNET_HashCode)))
+      eval = GNUNET_BLOCK_evaluate (block_ctx,
+                                   prq->type,
+                                   key,
+                                   &pr->bf,
+                                   pr->mingle,
+                                   pr->namespace, sizeof (GNUNET_HashCode),
+                                   prq->data,
+                                   prq->size);
+      switch (eval)
        {
-         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                     _("Reply mismatched in terms of namespace.  Discarded.\n"));
+       case GNUNET_BLOCK_EVALUATION_OK_MORE:
+         break;
+       case GNUNET_BLOCK_EVALUATION_OK_LAST:
+         break;
+       case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
+         GNUNET_STATISTICS_update (stats,
+                                   gettext_noop ("# duplicate replies discarded (bloomfilter)"),
+                                   1,
+                                   GNUNET_NO);
+#if DEBUG_FS
+         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                     "Duplicate response `%s', discarding.\n",
+                     GNUNET_h2s (&mhash));
+#endif
+         return GNUNET_YES; /* duplicate */
+       case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
          return GNUNET_YES; /* wrong namespace */      
+       case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
+         GNUNET_break (0);
+         return GNUNET_YES;
+        case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
+          GNUNET_break (0);
+          return GNUNET_YES;
+       case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
+         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                     _("Block library does not support FS blocks\n"));
+         return GNUNET_NO;
        }
-      /* then: fall-through! */
+      if (pr->client_request_list != NULL)
+       {
+         if (pr->replies_seen_size == pr->replies_seen_off)
+           GNUNET_array_grow (pr->replies_seen,
+                              pr->replies_seen_size,
+                              pr->replies_seen_size * 2 + 4);  
+           GNUNET_CRYPTO_hash (prq->data,
+                               prq->size,
+                               &pr->replies_seen[pr->replies_seen_off++]);           
+           refresh_bloomfilter (pr);
+       }
+      break;
     case GNUNET_BLOCK_TYPE_KBLOCK:
     case GNUNET_BLOCK_TYPE_NBLOCK:
-      if (pr->bf != NULL) 
+      eval = GNUNET_BLOCK_evaluate (block_ctx,
+                                   prq->type,
+                                   key,
+                                   &pr->bf,
+                                   pr->mingle,
+                                   NULL, 0,
+                                   prq->data,
+                                   prq->size);
+      switch (eval)
        {
-         mingle_hash (&chash, pr->mingle, &mhash);
-         if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (pr->bf,
-                                                              &mhash))
-           {
-             GNUNET_STATISTICS_update (stats,
-                                       gettext_noop ("# duplicate replies discarded (bloomfilter)"),
-                                       1,
-                                       GNUNET_NO);
-#if DEBUG_FS
-             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                         "Duplicate response `%s', discarding.\n",
-                         GNUNET_h2s (&mhash));
-#endif
-             return GNUNET_YES; /* duplicate */
-           }
+       case GNUNET_BLOCK_EVALUATION_OK_MORE:
+         break;
+       case GNUNET_BLOCK_EVALUATION_OK_LAST:
+         break;
+       case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
+         GNUNET_STATISTICS_update (stats,
+                                   gettext_noop ("# duplicate replies discarded (bloomfilter)"),
+                                   1,
+                                   GNUNET_NO);
 #if DEBUG_FS
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                     "New response `%s', adding to filter.\n",
+                     "Duplicate response `%s', discarding.\n",
                      GNUNET_h2s (&mhash));
 #endif
+         return GNUNET_YES; /* duplicate */
+       case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
+         GNUNET_break_op (0);
+         return GNUNET_YES;
+       case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
+         GNUNET_break (0);
+         return GNUNET_YES;
+        case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
+          GNUNET_break (0);
+          return GNUNET_YES;
+       case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
+         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                     _("Block library does not support FS blocks\n"));
+         return GNUNET_NO;
        }
       if (pr->client_request_list != NULL)
        {
@@ -2657,13 +2695,11 @@ process_reply (void *cls,
            GNUNET_array_grow (pr->replies_seen,
                               pr->replies_seen_size,
                               pr->replies_seen_size * 2 + 4);  
-           pr->replies_seen[pr->replies_seen_off++] = chash;         
+           GNUNET_CRYPTO_hash (prq->data,
+                               prq->size,
+                               &pr->replies_seen[pr->replies_seen_off++]);           
+           refresh_bloomfilter (pr);
        }
-      if ( (pr->bf == NULL) ||
-          (pr->client_request_list != NULL) )
-       refresh_bloomfilter (pr);
-      GNUNET_CONTAINER_bloomfilter_add (pr->bf,
-                                       &mhash);
       break;
     default:
       GNUNET_break (0);
@@ -3027,9 +3063,9 @@ process_local_reply (void *cls,
     }
   /* check for duplicates */
   GNUNET_CRYPTO_hash (data, size, &dhash);
-  mingle_hash (&dhash, 
-              pr->mingle,
-              &mhash);
+  GNUNET_BLOCK_mingle_hash (&dhash, 
+                           pr->mingle,
+                           &mhash);
   if ( (pr->bf != NULL) &&
        (GNUNET_YES ==
        GNUNET_CONTAINER_bloomfilter_test (pr->bf,