- allow GNUNET_BLOCK_evaluate on PUT requests for regex blocks

1 files changed, 162 insertions, 90 deletions

diff --git a/src/regex/plugin_block_regex.c b/src/regex/plugin_block_regex.c
index d3c973560..bfee12d7f 100644
--- a/src/regex/plugin_block_regex.c
+++ b/src/regex/plugin_block_regex.c
@@ -59,6 +59,157 @@ rdebug (void *cls,
 
 
 /**
+ * Function called to validate a reply or a request of type
+ * GNUNET_BLOCK_TYPE_REGEX.
+ * For request evaluation, 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 "get_key" function.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param query original query (hash)
+ * @param bf pointer to bloom filter associated with query; possibly updated (!)
+ * @param bf_mutator mutation value for bf
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in reply block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_EvaluationResult
+evaluate_block_regex (void *cls, enum GNUNET_BLOCK_Type type,
+                      const struct GNUNET_HashCode * query,
+                      struct GNUNET_CONTAINER_BloomFilter **bf,
+                      int32_t bf_mutator, const void *xquery,
+                      size_t xquery_size, const void *reply_block,
+                      size_t reply_block_size)
+{
+  if (NULL == reply_block) /* queries (GET) are always valid */
+    return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
+  if (0 != xquery_size)
+  {
+    const char *query;
+
+    query = (const char *) xquery;
+    if ('\0' != query[xquery_size - 1]) /* must be valid string */
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Block xquery not a valid string\n");
+      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+    }
+  }
+  else if (NULL != query) /* PUTs don't need xquery */
+  {
+    const struct RegexBlock *rblock = reply_block;
+
+    GNUNET_break_op (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Block with no xquery\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  key: %s, %u edges\n",
+                GNUNET_h2s (&rblock->key), ntohl (rblock->n_edges));
+    GNUNET_REGEX_block_iterate (rblock, reply_block_size, &rdebug, NULL);
+    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+  }
+  switch (GNUNET_REGEX_block_check (reply_block,
+                                    reply_block_size,
+                                    xquery))
+  {
+    case GNUNET_SYSERR:
+      GNUNET_break_op(0);
+      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+    case GNUNET_NO:
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "BLOCK XQUERY %s not accepted\n", xquery);
+      return GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT;
+    default:
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "BLOCK XQUERY %s accepted\n", xquery);
+      break;
+  }
+  if (NULL != bf)
+  {
+    struct GNUNET_HashCode chash;
+    struct GNUNET_HashCode mhash;
+
+    GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
+    GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
+    if (NULL != *bf)
+    {
+      if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
+        return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
+    }
+    else
+    {
+      *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
+    }
+    GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
+  }
+  return GNUNET_BLOCK_EVALUATION_OK_MORE;
+}
+
+
+/**
+ * Function called to validate a reply or a request of type
+ * GNUNET_BLOCK_TYPE_REGEX_ACCEPT.
+ * For request evaluation, 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 "get_key" function.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param query original query (hash)
+ * @param bf pointer to bloom filter associated with query; possibly updated (!)
+ * @param bf_mutator mutation value for bf
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in reply block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_EvaluationResult
+evaluate_block_regex_accept (void *cls, enum GNUNET_BLOCK_Type type,
+                             const struct GNUNET_HashCode * query,
+                             struct GNUNET_CONTAINER_BloomFilter **bf,
+                             int32_t bf_mutator, const void *xquery,
+                             size_t xquery_size, const void *reply_block,
+                             size_t reply_block_size)
+{
+  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 (sizeof (struct RegexAccept) != reply_block_size)
+  {
+    GNUNET_break_op(0);
+    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+  }
+  if (NULL != bf)
+  {
+    struct GNUNET_HashCode chash;
+    struct GNUNET_HashCode mhash;
+
+    GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
+    GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
+    if (NULL != *bf)
+    {
+      if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
+        return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
+    }
+    else
+    {
+      *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
+    }
+    GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
+  }
+  return GNUNET_BLOCK_EVALUATION_OK_MORE;
+}
+
+
+/**
  * 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
@@ -84,105 +235,26 @@ block_plugin_regex_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
                              size_t xquery_size, const void *reply_block,
                              size_t reply_block_size)
 {
-  struct GNUNET_HashCode chash;
-  struct GNUNET_HashCode mhash;
+  enum GNUNET_BLOCK_EvaluationResult result;
 
   switch (type)
   {
     case GNUNET_BLOCK_TYPE_REGEX:
-      if (NULL == reply_block)
-        return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-      if (0 != xquery_size)
-      {
-        const char *query;
-
-        query = (const char *) xquery;
-        if ('\0' != query[xquery_size - 1]) /* must be valid string */
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      "Block xquery not a valid string\n");
-          return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-        }
-      }
-      else
-      {
-        const struct RegexBlock *rblock = reply_block;
-
-        GNUNET_break_op (0);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Block with no xquery\n");
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  key: %s, %u edges\n",
-                    GNUNET_h2s (&rblock->key), ntohl (rblock->n_edges));
-        GNUNET_REGEX_block_iterate (rblock, reply_block_size, &rdebug, NULL);
-        return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-      }
-      switch (GNUNET_REGEX_block_check (reply_block,
-                                        reply_block_size,
-                                        xquery))
-      {
-        case GNUNET_SYSERR:
-          GNUNET_break_op(0);
-          return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-        case GNUNET_NO:
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "BLOCK XQUERY %s not accepted\n", xquery);
-          return GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT;
-        default:
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "BLOCK XQUERY %s accepted\n", xquery);
-          break;
-      }
-      if (NULL != bf)
-      {
-        GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
-        GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
-        if (NULL != *bf)
-        {
-          if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
-            return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
-        }
-        else
-        {
-          *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
-        }
-        GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
-      }
-      return GNUNET_BLOCK_EVALUATION_OK_MORE;
-
+      result = evaluate_block_regex (cls, type, query, bf, bf_mutator,
+                                     xquery, xquery_size,
+                                     reply_block, reply_block_size);
+      break;
 
     case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
-      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 (sizeof (struct RegexAccept) != reply_block_size)
-      {
-        GNUNET_break_op(0);
-        return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-      }
-      if (NULL != bf)
-      {
-        GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
-        GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
-        if (NULL != *bf)
-        {
-          if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
-            return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
-        }
-        else
-        {
-          *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
-        }
-        GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
-      }
-      return GNUNET_BLOCK_EVALUATION_OK_MORE;
-
+      result = evaluate_block_regex_accept (cls, type, query, bf, bf_mutator,
+                                            xquery, xquery_size,
+                                            reply_block, reply_block_size);
+      break;
 
     default:
-      return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
+      result = GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
   }
+  return result;
 }