X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fregex%2Fregex_block_lib.c;h=782827d5db0424782f393d9557293fe01f3410d8;hb=f1ca38573f22205e28ac482efebe463696c9c2c7;hp=7b273e6d8982f5b33889e9a2a1cbbc2e1809ebe5;hpb=15a8471c0edc4134f57c19884c033a63f49a04dd;p=oweals%2Fgnunet.git

diff --git a/src/regex/regex_block_lib.c b/src/regex/regex_block_lib.c
index 7b273e6d8..782827d5d 100644
--- a/src/regex/regex_block_lib.c
+++ b/src/regex/regex_block_lib.c
@@ -97,8 +97,8 @@ GNUNET_NETWORK_STRUCT_END
  *
  * @param block block to test
  * @param size number of bytes in block
- * @return GNUNET_YES if the block is accepting, GNUNET_NO if not
- */ 
+ * @return #GNUNET_YES if the block is accepting, #GNUNET_NO if not
+ */
 int
 GNUNET_BLOCK_is_accepting (const struct RegexBlock *block,
 			   size_t size)
@@ -118,8 +118,7 @@ GNUNET_BLOCK_is_accepting (const struct RegexBlock *block,
  * @param proof partial regex of a state
  * @param proof_len number of bytes in 'proof'
  * @param key hash of a state.
- *
- * @return GNUNET_OK if the proof is valid for the given key.
+ * @return #GNUNET_OK if the proof is valid for the given key.
  */
 int
 REGEX_BLOCK_check_proof (const char *proof,
@@ -164,7 +163,7 @@ struct CheckEdgeContext
  * @param token Token that follows to next state.
  * @param len Lenght of token.
  * @param key Hash of next state.
- * 
+ *
  * @return GNUNET_YES, to keep iterating
  */
 static int
@@ -175,7 +174,7 @@ check_edge (void *cls,
 {
   struct CheckEdgeContext *ctx = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 	      "edge %.*s [%u]: %s->%s\n",
               (int) len, token, len, GNUNET_h2s(key));
   if (NULL == ctx->xquery)
@@ -196,10 +195,9 @@ check_edge (void *cls,
  * @param query the query for the block
  * @param xquery String describing the edge we are looking for.
  *               Can be NULL in case this is a put block.
- *
- * @return GNUNET_OK in case it's fine.
- *         GNUNET_NO in case the xquery exists and is not found (IRRELEVANT).
- *         GNUNET_SYSERR if the block is invalid.
+ * @return #GNUNET_OK in case it's fine.
+ *         #GNUNET_NO in case the xquery exists and is not found (IRRELEVANT).
+ *         #GNUNET_SYSERR if the block is invalid.
  */
 int
 REGEX_BLOCK_check (const struct RegexBlock *block,
@@ -211,23 +209,30 @@ REGEX_BLOCK_check (const struct RegexBlock *block,
   struct CheckEdgeContext ctx;
   int res;
 
-  if (GNUNET_OK != 
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Block check\n");
+  if (GNUNET_OK !=
       REGEX_BLOCK_get_key (block, size,
 			   &key))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  if (0 != memcmp (&key,
-		   query,
-		   sizeof (struct GNUNET_HashCode)))
+  if (NULL != query &&
+      0 != memcmp (&key,
+                   query,
+                   sizeof (struct GNUNET_HashCode)))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
   if ( (GNUNET_YES == ntohs (block->is_accepting)) &&
        ( (NULL == xquery) || ('\0' == xquery[0]) ) )
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "  out! Is accepting: %u, xquery %p\n",
+       ntohs(block->is_accepting), xquery);
     return GNUNET_OK;
+  }
   ctx.xquery = xquery;
   ctx.found = GNUNET_NO;
   res = REGEX_BLOCK_iterate (block, size, &check_edge, &ctx);
@@ -235,6 +240,7 @@ REGEX_BLOCK_check (const struct RegexBlock *block,
     return GNUNET_SYSERR;
   if (NULL == xquery)
     return GNUNET_YES;
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Result %d\n", ctx.found);
   return ctx.found;
 }
 
@@ -244,13 +250,13 @@ REGEX_BLOCK_check (const struct RegexBlock *block,
  *
  * @param block block to get the key from
  * @param block_len number of bytes in block
- * @param query where to store the key
- * @return GNUNET_OK on success, GNUNET_SYSERR if the block is malformed
+ * @param key where to store the key
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the block is malformed
  */
 int
 REGEX_BLOCK_get_key (const struct RegexBlock *block,
-		     size_t block_len,
-		     struct GNUNET_HashCode *key)
+                     size_t block_len,
+                     struct GNUNET_HashCode *key)
 {
   uint16_t len;
   const struct GNUNET_HashCode *destinations;
@@ -259,17 +265,17 @@ REGEX_BLOCK_get_key (const struct RegexBlock *block,
   uint16_t num_edges;
   size_t total;
 
-  if (block_len < sizeof (struct RegexBlock)) 
+  if (block_len < sizeof (struct RegexBlock))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
-  }  
+  }
   num_destinations = ntohs (block->num_destinations);
   num_edges = ntohs (block->num_edges);
   len = ntohs (block->proof_len);
   destinations = (const struct GNUNET_HashCode *) &block[1];
   edges = (const struct EdgeInfo *) &destinations[num_destinations];
-  total = sizeof (struct RegexBlock) + num_destinations * sizeof (struct GNUNET_HashCode) + num_edges + sizeof (struct EdgeInfo) + len;  
+  total = sizeof (struct RegexBlock) + num_destinations * sizeof (struct GNUNET_HashCode) + num_edges * sizeof (struct EdgeInfo) + len;
   if (block_len < total)
   {
     GNUNET_break_op (0);
@@ -284,14 +290,13 @@ REGEX_BLOCK_get_key (const struct RegexBlock *block,
  * Iterate over all edges of a block of a regex state.
  *
  * @param block Block to iterate over.
- * @param size Size of block.
+ * @param size Size of @a block.
  * @param iterator Function to call on each edge in the block.
- * @param iter_cls Closure for the iterator.
- *
- * @return GNUNET_SYSERR if an error has been encountered.
- *         GNUNET_OK if no error has been encountered.
+ * @param iter_cls Closure for the @a iterator.
+ * @return #GNUNET_SYSERR if an error has been encountered.
+ *         #GNUNET_OK if no error has been encountered.
  *           Note that if the iterator stops the iteration by returning
- *         GNUNET_NO, the block will no longer be checked for further errors.
+ *         #GNUNET_NO, the block will no longer be checked for further errors.
  *           The return value will be GNUNET_OK meaning that no errors were
  *         found until the edge last notified to the iterator, but there might
  *         be errors in further edges.
@@ -312,7 +317,8 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
   unsigned int n;
   size_t off;
 
-  if (size < sizeof (struct RegexBlock)) 
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Block iterate\n");
+  if (size < sizeof (struct RegexBlock))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
@@ -324,14 +330,14 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
   edges = (const struct EdgeInfo *) &destinations[num_destinations];
   aux = (const char *) &edges[num_edges];
   total = sizeof (struct RegexBlock) + num_destinations * sizeof (struct GNUNET_HashCode) + num_edges * sizeof (struct EdgeInfo) + len;
-  if (size < total) 
+  if (size < total)
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
   for (n=0;n<num_edges;n++)
-    total += ntohs (edges[n].token_length);    
-  if (size != total) 
+    total += ntohs (edges[n].token_length);
+  if (size != total)
   {
     fprintf (stderr, "Expected %u, got %u\n",
 	     (unsigned int) size,
@@ -347,11 +353,13 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
   for (n=0;n<num_edges;n++)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-	 "Edge %u, off %u tokenlen %u\n", n, off,
-	 ntohs (edges[n].token_length));
+	 "Edge %u/%u, off %u tokenlen %u (%.*s)\n",
+         n+1, num_edges, off,
+	 ntohs (edges[n].token_length), ntohs (edges[n].token_length),
+         &aux[off]);
     if (NULL != iterator)
-      if (GNUNET_NO == iterator (iter_cls, 
-				 &aux[off], 
+      if (GNUNET_NO == iterator (iter_cls,
+				 &aux[off],
 				 ntohs (edges[n].token_length),
 				 &destinations[ntohs (edges[n].destination_index)]))
 	return GNUNET_OK;
@@ -393,7 +401,7 @@ REGEX_BLOCK_create (const char *proof,
   char *aux;
 
   len = strlen (proof);
-  if (len > UINT16_MAX) 
+  if (len > UINT16_MAX)
   {
     GNUNET_break (0);
     return NULL;
@@ -403,7 +411,7 @@ REGEX_BLOCK_create (const char *proof,
   for (i=0;i<num_edges;i++)
   {
     slen = strlen (edges[i].label);
-    if (len > UINT16_MAX) 
+    if (slen > UINT16_MAX)
     {
       GNUNET_break (0);
       return NULL;
@@ -439,7 +447,7 @@ REGEX_BLOCK_create (const char *proof,
   edgeinfos = (struct EdgeInfo *) &dests[unique_destinations];
   aux = (char *) &edgeinfos[num_edges];
   off = len;
-  memcpy (aux, proof, len); 
+  memcpy (aux, proof, len);
   for (i=0;i<num_edges;i++)
   {
     slen = strlen (edges[i].label);