revise block API to match latest DHT specs

2 files changed, 59 insertions, 132 deletions

diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index beb29a506..154c454ca 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -247,7 +247,8 @@ static unsigned long long max_pending_requests = (32 * 1024);
  * @param pr request for which the BF is to be recomputed
  */
 static void
-refresh_bloomfilter (enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr)
+refresh_bloomfilter (enum GNUNET_BLOCK_Type type,
+                     struct GSF_PendingRequest *pr)
 {
   if (NULL != pr->bg)
   {
@@ -406,7 +407,7 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
         break;     /* let the request live briefly... */
       if (NULL != dpr->rh)
         dpr->rh (dpr->rh_cls,
-                 GNUNET_BLOCK_EVALUATION_REQUEST_VALID,
+                 GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED,
                  dpr,
                  UINT32_MAX,
                  GNUNET_TIME_UNIT_FOREVER_ABS,
@@ -557,7 +558,10 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr)
     k++;
   }
   if (GNUNET_OK !=
-      GNUNET_BLOCK_group_serialize (pr->bg, &bf_nonce, &bf_data, &bf_size))
+      GNUNET_BLOCK_group_serialize (pr->bg,
+                                    &bf_nonce,
+                                    &bf_data,
+                                    &bf_size))
   {
     bf_size = 0;
     bf_data = NULL;
@@ -765,11 +769,6 @@ struct ProcessReplyClosure
   enum GNUNET_BLOCK_Type type;
 
   /**
-   * Control flags for evaluation.
-   */
-  enum GNUNET_BLOCK_EvaluationOptions eo;
-
-  /**
    * How much was this reply worth to us?
    */
   uint32_t priority;
@@ -850,7 +849,6 @@ process_reply (void *cls,
   case GNUNET_BLOCK_REPLY_OK_MORE:
     update_request_performance_data (prq, pr);
     break;
-
   case GNUNET_BLOCK_REPLY_OK_LAST:
     /* short cut: stop processing early, no BF-update, etc. */
     update_request_performance_data (prq, pr);
@@ -885,7 +883,6 @@ process_reply (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Duplicate response, discarding.\n");
     return GNUNET_YES;   /* duplicate */
-
   case GNUNET_BLOCK_REPLY_IRRELEVANT:
     GNUNET_STATISTICS_update (GSF_stats,
                               "# irrelevant replies discarded",
@@ -894,8 +891,6 @@ process_reply (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Irrelevant response, ignoring.\n");
     return GNUNET_YES;
-  case GNUNET_BLOCK_REPLY_INVALID:
-    return GNUNET_YES;
   case GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED:
     GNUNET_break (0); /* bad installation? */
     return GNUNET_NO;
@@ -1127,8 +1122,9 @@ handle_dht_reply (void *cls,
                                              prq.expiration);
   prq.size = size;
   prq.type = type;
-  prq.eo = GNUNET_BLOCK_EO_NONE;
-  process_reply (&prq, key, pr);
+  process_reply (&prq,
+                 key,
+                 pr);
   if ((GNUNET_YES == active_to_migration) &&
       (GNUNET_NO == test_put_load_too_high (prq.priority)))
   {
@@ -1229,6 +1225,15 @@ cadet_reply_proc (void *cls,
   struct GNUNET_HashCode query;
 
   pr->cadet_request = NULL;
+  if (GNUNET_OK !=
+      GNUNET_BLOCK_check_block (GSF_block_ctx,
+                                type,
+                                data,
+                                data_size))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   if (GNUNET_BLOCK_TYPE_ANY == type)
   {
     GNUNET_break (NULL == data);
@@ -1247,7 +1252,11 @@ cadet_reply_proc (void *cls,
     return;
   }
   if (GNUNET_YES !=
-      GNUNET_BLOCK_get_key (GSF_block_ctx, type, data, data_size, &query))
+      GNUNET_BLOCK_get_key (GSF_block_ctx,
+                            type,
+                            data,
+                            data_size,
+                            &query))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Failed to derive key for block of type %d\n",
@@ -1268,8 +1277,9 @@ cadet_reply_proc (void *cls,
                                              prq.expiration);
   prq.size = data_size;
   prq.type = type;
-  prq.eo = GNUNET_BLOCK_EO_NONE;
-  process_reply (&prq, &query, pr);
+  process_reply (&prq,
+                 &query,
+                 pr);
 }
 
 
@@ -1611,7 +1621,11 @@ called_from_on_demand:
   prq.expiration = expiration;
   prq.size = size;
   if (GNUNET_OK !=
-      GNUNET_BLOCK_get_key (GSF_block_ctx, type, data, size, &query))
+      GNUNET_BLOCK_get_key (GSF_block_ctx,
+                            type,
+                            data,
+                            size,
+                            &query))
   {
     GNUNET_break (0);
     GNUNET_DATASTORE_remove (GSF_dsh,
@@ -1631,8 +1645,9 @@ called_from_on_demand:
   prq.anonymity_level = anonymity;
   if ((0 == old_rf) && (0 == pr->public_data.results_found))
     GSF_update_datastore_delay_ (pr->public_data.start_time);
-  prq.eo = GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO;
-  process_reply (&prq, key, pr);
+  process_reply (&prq,
+                 key,
+                 pr);
   pr->local_result = prq.eval;
   if (GNUNET_BLOCK_REPLY_OK_LAST == prq.eval)
   {
@@ -1720,7 +1735,8 @@ GSF_local_lookup_ (struct GSF_PendingRequest *pr,
  * @param put the actual message
  */
 void
-handle_p2p_put (void *cls, const struct PutMessage *put)
+handle_p2p_put (void *cls,
+                const struct PutMessage *put)
 {
   struct GSF_ConnectedPeer *cp = cls;
   uint16_t msize;
@@ -1746,7 +1762,20 @@ handle_p2p_put (void *cls, const struct PutMessage *put)
                                            GNUNET_TIME_UNIT_YEARS),
                                          expiration);
   if (GNUNET_OK !=
-      GNUNET_BLOCK_get_key (GSF_block_ctx, type, &put[1], dsize, &query))
+      GNUNET_BLOCK_check_block (GSF_block_ctx,
+                                type,
+                                &put[1],
+                                dsize))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  if (GNUNET_OK !=
+      GNUNET_BLOCK_get_key (GSF_block_ctx,
+                            type,
+                            &put[1],
+                            dsize,
+                            &query))
   {
     GNUNET_break_op (0);
     return;
@@ -1764,7 +1793,6 @@ handle_p2p_put (void *cls, const struct PutMessage *put)
   prq.priority = 0;
   prq.anonymity_level = UINT32_MAX;
   prq.request_found = GNUNET_NO;
-  prq.eo = GNUNET_BLOCK_EO_NONE;
   GNUNET_CONTAINER_multihashmap_get_multiple (pr_map,
                                               &query,
                                               &process_reply,
diff --git a/src/fs/plugin_block_fs.c b/src/fs/plugin_block_fs.c
index 43380b3b6..029f95bc5 100644
--- a/src/fs/plugin_block_fs.c
+++ b/src/fs/plugin_block_fs.c
@@ -111,110 +111,6 @@ block_plugin_fs_create_group (void *cls,
 
 
 /**
- * Function called to validate a reply or a request.  For
- * request evaluation, simply pass "NULL" for the reply_block.
- * Note that it is assumed that the reply has already been
- * matched to the key (and signatures checked) as it would
- * be done with the #GNUNET_BLOCK_get_key() function.
- *
- * @param cls closure
- * @param ctx block context
- * @param type block type
- * @param bg group to use for evaluation
- * @param eo control flags
- * @param query original query (hash)
- * @param xquery extrended query data (can be NULL, depending on type)
- * @param xquery_size number of bytes in @a xquery
- * @param reply_block response to validate
- * @param reply_block_size number of bytes in @a reply_block
- * @return characterization of result
- */
-static enum GNUNET_BLOCK_EvaluationResult
-block_plugin_fs_evaluate (void *cls,
-                          struct GNUNET_BLOCK_Context *ctx,
-                          enum GNUNET_BLOCK_Type type,
-                          struct GNUNET_BLOCK_Group *bg,
-                          enum GNUNET_BLOCK_EvaluationOptions eo,
-                          const struct GNUNET_HashCode *query,
-                          const void *xquery,
-                          size_t xquery_size,
-                          const void *reply_block,
-                          size_t reply_block_size)
-{
-  const struct UBlock *ub;
-  struct GNUNET_HashCode hc;
-  struct GNUNET_HashCode chash;
-
-  switch (type)
-  {
-  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
-  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
-    if (0 != xquery_size)
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-    }
-    if (NULL == reply_block)
-      return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-    return GNUNET_BLOCK_EVALUATION_OK_LAST;
-
-  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
-    if (0 != xquery_size)
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-    }
-    if (NULL == reply_block)
-      return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-
-    if (reply_block_size < sizeof(struct UBlock))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-    }
-    ub = reply_block;
-    GNUNET_CRYPTO_hash (&ub->verification_key,
-                        sizeof(ub->verification_key),
-                        &hc);
-    if (0 != memcmp (&hc,
-                     query,
-                     sizeof(struct GNUNET_HashCode)))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-    }
-    if (reply_block_size != ntohl (ub->purpose.size) + sizeof(struct
-                                                              GNUNET_CRYPTO_EcdsaSignature))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-    }
-    if ((0 == (eo & GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO)) &&
-        (GNUNET_OK !=
-         GNUNET_CRYPTO_ecdsa_verify_ (GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK,
-                                      &ub->purpose,
-                                      &ub->signature,
-                                      &ub->verification_key)))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-    }
-    GNUNET_CRYPTO_hash (reply_block,
-                        reply_block_size,
-                        &chash);
-    if (GNUNET_YES ==
-        GNUNET_BLOCK_GROUP_bf_test_and_set (bg,
-                                            &chash))
-      return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
-    return GNUNET_BLOCK_EVALUATION_OK_MORE;
-
-  default:
-    return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
-  }
-}
-
-
-/**
  * Function called to obtain the key for a block.
  *
  * @param cls closure
@@ -245,8 +141,11 @@ block_plugin_fs_get_key (void *cls,
   case GNUNET_BLOCK_TYPE_FS_UBLOCK:
     if (block_size < sizeof(struct UBlock))
     {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
+      GNUNET_break_op (0);
+      memset (key,
+              0,
+              sizeof (*key));
+      return GNUNET_OK;
     }
     ub = block;
     GNUNET_CRYPTO_hash (&ub->verification_key,
@@ -290,6 +189,7 @@ block_plugin_fs_check_query (void *cls,
     }
     return GNUNET_OK;
   default:
+    GNUNET_break (0);
     return GNUNET_SYSERR;
   }
 }
@@ -300,7 +200,6 @@ block_plugin_fs_check_query (void *cls,
  *
  * @param cls closure
  * @param type block type
- * @param query key for the block (hash), must match exactly
  * @param block block data to validate
  * @param block_size number of bytes in @a block
  * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
@@ -308,7 +207,6 @@ block_plugin_fs_check_query (void *cls,
 static enum GNUNET_GenericReturnValue
 block_plugin_fs_check_block (void *cls,
                              enum GNUNET_BLOCK_Type type,
-                             const struct GNUNET_HashCode *query,
                              const void *block,
                              size_t block_size)
 {
@@ -346,6 +244,7 @@ block_plugin_fs_check_block (void *cls,
       return GNUNET_OK;
     }
   default:
+    GNUNET_break (0);
     return GNUNET_SYSERR;
   }
 }
@@ -396,6 +295,7 @@ block_plugin_fs_check_reply (void *cls,
       return GNUNET_BLOCK_REPLY_OK_MORE;
     }
   default:
+    GNUNET_break (0);
     return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
   }
 }
@@ -416,7 +316,6 @@ libgnunet_plugin_block_fs_init (void *cls)
   struct GNUNET_BLOCK_PluginFunctions *api;
 
   api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
-  api->evaluate = &block_plugin_fs_evaluate;
   api->get_key = &block_plugin_fs_get_key;
   api->create_group = &block_plugin_fs_create_group;
   api->check_query = &block_plugin_fs_check_query;