- allow GNUNET_BLOCK_evaluate on PUT requests for regex blocks

1 files changed, 30 insertions, 44 deletions

diff --git a/src/regex/regex_block_lib.c b/src/regex/regex_block_lib.c
index deb496fd9c..3f7c9473a8 100644
--- a/src/regex/regex_block_lib.c
+++ b/src/regex/regex_block_lib.c
@@ -62,7 +62,9 @@ check_edge (void *cls,
   struct regex_block_xquery_ctx *ctx = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  edge %.*s [%u]\n",
-	      (int) len, token, len);
+              (int) len, token, len);
+  if (NULL == ctx->xquery)
+    return GNUNET_YES;
   if (strlen (ctx->xquery) < len)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  too long!\n");
@@ -82,54 +84,37 @@ check_edge (void *cls,
 }
 
 
-/**
- * Check if the regex block is well formed, including all edges
- *
- * @param block The start of the block.
- * @param size The size of the block.
- * @param xquery String describing the edge we are looking for.
- *
- * @return GNUNET_OK in case it's fine.
- *         GNUNET_NO in case the xquery is not found.
- *         GNUNET_SYSERR if the block is invalid.
- */
 int
 GNUNET_REGEX_block_check (const struct RegexBlock *block,
-                                size_t size,
-                                const char *xquery)
+                          size_t size,
+                          const char *xquery)
 {
   int res;
   struct regex_block_xquery_ctx ctx;
 
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "* Checking block with xquery \"%s\"\n",
-                xquery);
-  if ( (GNUNET_YES == ntohl(block->accepting)) && ('\0' == xquery[0]) )
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "* Checking block with xquery \"%s\"\n",
+              NULL != xquery ? xquery : "NULL");
+  if ( (GNUNET_YES == ntohl (block->accepting)) &&
+       ( (NULL == xquery) || ('\0' == xquery[0]) )
+     )
     return GNUNET_OK;
   ctx.xquery = xquery;
   ctx.found = GNUNET_NO;
   res = GNUNET_REGEX_block_iterate (block, size, &check_edge, &ctx);
   if (GNUNET_SYSERR == res)
     return GNUNET_SYSERR;
+  if (NULL == xquery)
+    return GNUNET_YES;
   return ctx.found;
 }
 
 
-/**
- * Iterate over all edges of a block of a regex state.
- *
- * @param block Block to iterate over.
- * @param size Size of block.
- * @param iterator Function to call on each edge in the block.
- * @param iter_cls Closure for the iterator.
- *
- * @return How many bytes of block have been processed
- */
 int
 GNUNET_REGEX_block_iterate (const struct RegexBlock *block,
-                                  size_t size,
-                                  GNUNET_REGEX_EgdeIterator iterator,
-                                  void *iter_cls)
+                            size_t size,
+                            GNUNET_REGEX_EgdeIterator iterator,
+                            void *iter_cls)
 {
   struct RegexEdge *edge;
   unsigned int n;
@@ -142,7 +127,7 @@ GNUNET_REGEX_block_iterate (const struct RegexBlock *block,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "* Start iterating block of size %u, off %u\n",
        size, offset);
-  if (offset > size) // Is it safe to access the regex block?
+  if (offset >= size) /* Is it safe to access the regex block? */
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
          "*   Block is smaller than struct RegexBlock, END\n");
@@ -153,22 +138,23 @@ GNUNET_REGEX_block_iterate (const struct RegexBlock *block,
   offset += n;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "*  Proof length: %u, off %u\n", n, offset);
-  if (offset > size) // Is it safe to access the regex proof?
+  if (offset >= size) /* Is it safe to access the regex proof? */
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
          "*   Block is smaller than Block + proof, END\n");
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  aux = (char *) &block[1];  // Skip regex block
-  aux = &aux[n];             // Skip regex proof
+  aux = (char *) &block[1];  /* Skip regex block */
+  aux = &aux[n];             /* Skip regex proof */
   n = ntohl (block->n_edges);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "*  Edges: %u\n", n);
-  for (i = 0; i < n; i++) // aux always points at the end of the previous block
+  /* aux always points at the end of the previous block */
+  for (i = 0; i < n; i++)
   {
     offset += sizeof (struct RegexEdge);
     LOG (GNUNET_ERROR_TYPE_DEBUG, "*   Edge %u, off %u\n", i, offset);
-    if (offset > size) // Is it safe to access the next edge block?
+    if (offset >= size) /* Is it safe to access the next edge block? */
     {
       LOG (GNUNET_ERROR_TYPE_WARNING,
            "*   Size not enough for RegexEdge, END\n");
@@ -179,23 +165,23 @@ GNUNET_REGEX_block_iterate (const struct RegexBlock *block,
     n_token = ntohl (edge->n_token);
     offset += n_token;
     LOG (GNUNET_ERROR_TYPE_DEBUG, 
-         "*    Token lenght %u, off %u\n", n_token, offset);
-    if (offset > size) // Is it safe to access the edge token?
+         "*    Token length %u, off %u\n", n_token, offset);
+    if (offset > size) /* Is it safe to access the edge token? */
     {
       LOG (GNUNET_ERROR_TYPE_WARNING,
            "*   Size not enough for edge token, END\n");
       GNUNET_break_op (0);
       return GNUNET_SYSERR;
     }
-    aux = (char *) &edge[1]; // Skip edge block
+    aux = (char *) &edge[1]; /* Skip edge block */
     if (NULL != iterator)
         if (GNUNET_NO == iterator (iter_cls, aux, n_token, &edge->key))
             return GNUNET_OK;
-    aux = &aux[n_token];     // Skip edge token
+    aux = &aux[n_token];     /* Skip edge token */
   }
-  // The total size should be exactly the size of (regex + all edges) blocks
-  // If size == -1, block is from cache and therefore previously checked and
-  // assumed correct.
+  /* The total size should be exactly the size of (regex + all edges) blocks
+   * If size == -1, block is from cache and therefore previously checked and
+   * assumed correct. */
   if (offset == size || SIZE_MAX == size)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "* Block processed, END OK\n");