1 files changed, 20 insertions, 267 deletions

diff --git a/src/regex/plugin_block_regex.c b/src/regex/plugin_block_regex.c
index 0953830ab..61442ac10 100644
--- a/src/regex/plugin_block_regex.c
+++ b/src/regex/plugin_block_regex.c
@@ -93,242 +93,6 @@ block_plugin_regex_create_group (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 #GNUNET_BLOCK_get_key() function.
- *
- * @param cls closure
- * @param type block type
- * @param bg block group to evaluate against
- * @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
-evaluate_block_regex (void *cls,
-                      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)
-{
-  struct GNUNET_HashCode chash;
-
-  if (NULL == reply_block)
-  {
-    if (0 != xquery_size)
-    {
-      const char *s;
-
-      s = (const char *) xquery;
-      if ('\0' != s[xquery_size - 1])     /* must be valid 0-terminated string */
-      {
-        GNUNET_break_op (0);
-        return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-      }
-    }
-    return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-  }
-  if (0 != xquery_size)
-  {
-    const char *s;
-
-    s = (const char *) xquery;
-    if ('\0' != s[xquery_size - 1])   /* must be valid 0-terminated string */
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-    }
-  }
-  else if (NULL != query)
-  {
-    /* xquery is required for regex GETs, at least an empty string */
-    GNUNET_break_op (0);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "type %d, query %p, xquery %p\n",
-                type, query, xquery);
-    return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-  }
-  switch (REGEX_BLOCK_check (reply_block,
-                             reply_block_size,
-                             query,
-                             xquery))
-  {
-  case GNUNET_SYSERR:
-    GNUNET_break_op (0);
-    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-
-  case GNUNET_NO:
-    /* xquery mismatch, can happen */
-    return GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT;
-
-  default:
-    break;
-  }
-  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;
-}
-
-
-/**
- * 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 #GNUNET_BLOCK_get_key() function.
- *
- * @param cls closure
- * @param type block type
- * @param bg block group to evaluate against
- * @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
-evaluate_block_regex_accept (void *cls,
-                             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 RegexAcceptBlock *rba;
-  struct GNUNET_HashCode chash;
-
-  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 RegexAcceptBlock) != reply_block_size)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-  }
-  rba = reply_block;
-  if (ntohl (rba->purpose.size) !=
-      sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
-      + sizeof(struct GNUNET_TIME_AbsoluteNBO)
-      + sizeof(struct GNUNET_HashCode))
-  {
-    GNUNET_break_op (0);
-    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-  }
-  if (0 == GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (
-                                                 rba->expiration_time)).
-      rel_value_us)
-  {
-    /* technically invalid, but can happen without an error, so
-       we're nice by reporting it as a 'duplicate' */
-    return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
-  }
-  if (GNUNET_OK !=
-      GNUNET_CRYPTO_eddsa_verify_ (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT,
-                                   &rba->purpose,
-                                   &rba->signature,
-                                   &rba->peer.public_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;
-}
-
-
-/**
- * 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 evaluate against
- * @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 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
-block_plugin_regex_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)
-{
-  enum GNUNET_BLOCK_EvaluationResult result;
-
-  switch (type)
-  {
-  case GNUNET_BLOCK_TYPE_REGEX:
-    result = evaluate_block_regex (cls,
-                                   type,
-                                   bg,
-                                   eo,
-                                   query,
-                                   xquery, xquery_size,
-                                   reply_block, reply_block_size);
-    break;
-
-  case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
-    result = evaluate_block_regex_accept (cls,
-                                          type,
-                                          bg,
-                                          eo,
-                                          query,
-                                          xquery, xquery_size,
-                                          reply_block, reply_block_size);
-    break;
-
-  default:
-    result = GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
-  }
-  return result;
-}
-
-
-/**
  * Function called to validate a query.
  *
  * @param cls closure
@@ -341,10 +105,10 @@ block_plugin_regex_evaluate (void *cls,
  */
 static enum GNUNET_GenericReturnValue
 block_plugin_regex_check_query (void *cls,
-                                    enum GNUNET_BLOCK_Type type,
-                                    const struct GNUNET_HashCode *query,
-                                    const void *xquery,
-                                    size_t xquery_size)
+                                enum GNUNET_BLOCK_Type type,
+                                const struct GNUNET_HashCode *query,
+                                const void *xquery,
+                                size_t xquery_size)
 {
   switch (type)
   {
@@ -380,7 +144,6 @@ block_plugin_regex_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
@@ -388,7 +151,6 @@ block_plugin_regex_check_query (void *cls,
 static enum GNUNET_GenericReturnValue
 block_plugin_regex_check_block (void *cls,
                                     enum GNUNET_BLOCK_Type type,
-                                    const struct GNUNET_HashCode *query,
                                     const void *block,
                                     size_t block_size)
 {
@@ -398,7 +160,7 @@ block_plugin_regex_check_block (void *cls,
     if (GNUNET_SYSERR ==
         REGEX_BLOCK_check (block,
                            block_size,
-                           query,
+                           NULL,
                            NULL))
       return GNUNET_NO;
     return GNUNET_OK;
@@ -480,12 +242,7 @@ block_plugin_regex_check_reply (
       const char *s;
       
       s = (const char *) xquery;
-      if ('\0' != s[xquery_size - 1])   /* must be valid 0-terminated string */
-      {
-        /* Technically, the query is invalid ... */
-        GNUNET_break (0);
-        return GNUNET_BLOCK_REPLY_INVALID;
-      }
+      GNUNET_assert ('\0' == s[xquery_size - 1]);
     }
     switch (REGEX_BLOCK_check (reply_block,
                                reply_block_size,
@@ -493,8 +250,7 @@ block_plugin_regex_check_reply (
                                xquery))
     {
     case GNUNET_SYSERR:
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_REPLY_INVALID;
+      GNUNET_assert (0);
     case GNUNET_NO:
       /* xquery mismatch, can happen */
       return GNUNET_BLOCK_REPLY_IRRELEVANT;
@@ -513,20 +269,12 @@ block_plugin_regex_check_reply (
     {
     const struct RegexAcceptBlock *rba;
 
-    if (sizeof(struct RegexAcceptBlock) != reply_block_size)
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_REPLY_INVALID;
-    }
+    GNUNET_assert (sizeof(struct RegexAcceptBlock) == reply_block_size);
     rba = reply_block;
-    if (ntohl (rba->purpose.size) !=
+    GNUNET_assert (ntohl (rba->purpose.size) ==
         sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
         + sizeof(struct GNUNET_TIME_AbsoluteNBO)
-        + sizeof(struct GNUNET_HashCode))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_REPLY_INVALID;
-    }
+                   + sizeof(struct GNUNET_HashCode));
     GNUNET_CRYPTO_hash (reply_block,
                         reply_block_size,
                         &chash);
@@ -552,8 +300,8 @@ block_plugin_regex_check_reply (
  * @param block block to get the key for
  * @param block_size number of bytes in @a block
  * @param key set to the key (query) for the given block
- * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
- *         (or if extracting a key from a block of this type does not work)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported,
+ *         #GNUNET_NO if extracting a key from a block of this type does not work
  */
 static enum GNUNET_GenericReturnValue
 block_plugin_regex_get_key (void *cls,
@@ -571,14 +319,20 @@ block_plugin_regex_get_key (void *cls,
                              key))
     {
       GNUNET_break_op (0);
-      return GNUNET_NO;
+      memset (key,
+              0,
+              sizeof (*key));
+      return GNUNET_OK;
     }
     return GNUNET_OK;
   case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
     if (sizeof(struct RegexAcceptBlock) != block_size)
     {
       GNUNET_break_op (0);
-      return GNUNET_NO;
+      memset (key,
+              0,
+              sizeof (*key));
+      return GNUNET_OK;
     }
     *key = ((struct RegexAcceptBlock *) block)->key;
     return GNUNET_OK;
@@ -603,7 +357,6 @@ libgnunet_plugin_block_regex_init (void *cls)
   struct GNUNET_BLOCK_PluginFunctions *api;
 
   api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
-  api->evaluate = &block_plugin_regex_evaluate;
   api->get_key = &block_plugin_regex_get_key;
   api->check_query = &block_plugin_regex_check_query;
   api->check_block = &block_plugin_regex_check_block;