add logging and in particular checks to make sure no '.' wildcards are during initial transitions of the DFA

5 files changed, 253 insertions, 167 deletions

diff --git a/src/regex/regex_block_lib.h b/src/regex/regex_block_lib.h
index e5685ba9a2..20cfd6cebe 100644
--- a/src/regex/regex_block_lib.h
+++ b/src/regex/regex_block_lib.h
@@ -52,7 +52,8 @@ struct RegexBlock;
 struct REGEX_BLOCK_Edge
 {
   /**
-   * Label of the edge.  FIXME: might want to not consume exactly multiples of 8 bits, need length!
+   * Label of the edge.  FIXME: might want to not consume exactly
+   * multiples of 8 bits, need length!
    */
   const char *label;
 
@@ -67,10 +68,9 @@ struct REGEX_BLOCK_Edge
  * Check if the given 'proof' matches the given 'key'.
  *
  * @param proof partial regex of a state
- * @param proof_len number of bytes in 'proof'
+ * @param proof_len number of bytes in @a 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,
@@ -82,14 +82,13 @@ REGEX_BLOCK_check_proof (const char *proof,
  * 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 query the query for the block
+ * @param size The size of the @a block.
+ * @param query the query for the @a 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,
@@ -107,13 +106,13 @@ REGEX_BLOCK_check (const struct RegexBlock *block,
  * @param token Token that follows to next state.
  * @param len Length of token.
  * @param key Hash of next state.
- *
- * @return GNUNET_YES if should keep iterating, GNUNET_NO otherwise.
+ * @return #GNUNET_YES if should keep iterating, #GNUNET_NO otherwise.
  */
-typedef int (*REGEX_INTERNAL_EgdeIterator)(void *cls,
-					   const char *token,
-					   size_t len,
-					   const struct GNUNET_HashCode *key);
+typedef int
+(*REGEX_INTERNAL_EgdeIterator)(void *cls,
+                               const char *token,
+                               size_t len,
+                               const struct GNUNET_HashCode *key);
 
 
 /**
@@ -122,29 +121,29 @@ typedef int (*REGEX_INTERNAL_EgdeIterator)(void *cls,
  * @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 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.
- *           The return value will be GNUNET_OK meaning that no errors were
+ *         #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.
  */
 int
 REGEX_BLOCK_iterate (const struct RegexBlock *block,
-                            size_t size,
-                            REGEX_INTERNAL_EgdeIterator iterator,
-                            void *iter_cls);
+                     size_t size,
+                     REGEX_INTERNAL_EgdeIterator iterator,
+                     void *iter_cls);
+
 
 /**
  * Obtain the key that a particular block is to be stored under.
  *
  * @param block block to get the key from
- * @param block_len number of bytes in block
+ * @param block_len number of bytes in @a block
  * @param key where to store the key
- * @return GNUNET_OK on success, GNUNET_SYSERR if the block is malformed
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the block is malformed
  */
 int
 REGEX_BLOCK_get_key (const struct RegexBlock *block,
@@ -157,7 +156,7 @@ REGEX_BLOCK_get_key (const struct RegexBlock *block,
  *
  * @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,
diff --git a/src/regex/regex_internal.c b/src/regex/regex_internal.c
index 56c6e74dea..2dccd657fd 100644
--- a/src/regex/regex_internal.c
+++ b/src/regex/regex_internal.c
@@ -31,7 +31,7 @@
 
 
 /**
- * Set this to GNUNET_YES to enable state naming. Used to debug NFA->DFA
+ * Set this to #GNUNET_YES to enable state naming. Used to debug NFA->DFA
  * creation. Disabled by default for better performance.
  */
 #define REGEX_DEBUG_DFA GNUNET_NO
@@ -59,7 +59,7 @@ struct REGEX_INTERNAL_StateSet_MDLL
 
 
 /**
- * Append state to the given StateSet '
+ * Append state to the given StateSet.
  *
  * @param set set to be modified
  * @param state state to be appended
@@ -95,7 +95,7 @@ nullstrcmp (const char *str1, const char *str2)
 
 
 /**
- * Adds a transition from one state to another on 'label'. Does not add
+ * Adds a transition from one state to another on @a label. Does not add
  * duplicate states.
  *
  * @param ctx context
@@ -105,7 +105,8 @@ nullstrcmp (const char *str1, const char *str2)
  */
 static void
 state_add_transition (struct REGEX_INTERNAL_Context *ctx,
-                      struct REGEX_INTERNAL_State *from_state, const char *label,
+                      struct REGEX_INTERNAL_State *from_state,
+                      const char *label,
                       struct REGEX_INTERNAL_State *to_state)
 {
   struct REGEX_INTERNAL_Transition *t;
@@ -113,7 +114,8 @@ state_add_transition (struct REGEX_INTERNAL_Context *ctx,
 
   if (NULL == from_state)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not create Transition.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not create Transition.\n");
     return;
   }
 
@@ -196,16 +198,17 @@ state_compare (const void *a, const void *b)
 
 
 /**
- * Get all edges leaving state 's'.
+ * Get all edges leaving state @a s.
  *
  * @param s state.
- * @param edges all edges leaving 's', expected to be allocated and have enough
- *        space for s->transitions_count elements.
+ * @param edges all edges leaving @a s, expected to be allocated and have enough
+ *        space for `s->transitions_count` elements.
  *
  * @return number of edges.
  */
 static unsigned int
-state_get_edges (struct REGEX_INTERNAL_State *s, struct REGEX_BLOCK_Edge *edges)
+state_get_edges (struct REGEX_INTERNAL_State *s,
+                 struct REGEX_BLOCK_Edge *edges)
 {
   struct REGEX_INTERNAL_Transition *t;
   unsigned int count;
@@ -293,7 +296,7 @@ automaton_fragment_clear (struct REGEX_INTERNAL_Automaton *a)
 
 
 /**
- * Frees the memory used by State 's'
+ * Frees the memory used by State @a s
  *
  * @param s state that should be destroyed
  */
@@ -498,17 +501,17 @@ automaton_state_traverse (struct REGEX_INTERNAL_State *s, int *marks,
  * @param start start state, pass a->start or NULL to traverse the whole automaton.
  * @param check function that is checked before advancing on each transition
  *              in the DFS.
- * @param check_cls closure for check.
+ * @param check_cls closure for @a check.
  * @param action action to be performed on each state.
- * @param action_cls closure for action
+ * @param action_cls closure for @a action
  */
 void
 REGEX_INTERNAL_automaton_traverse (const struct REGEX_INTERNAL_Automaton *a,
-                                 struct REGEX_INTERNAL_State *start,
-                                 REGEX_INTERNAL_traverse_check check,
-                                 void *check_cls,
-                                 REGEX_INTERNAL_traverse_action action,
-                                 void *action_cls)
+                                   struct REGEX_INTERNAL_State *start,
+                                   REGEX_INTERNAL_traverse_check check,
+                                   void *check_cls,
+                                   REGEX_INTERNAL_traverse_action action,
+                                   void *action_cls)
 {
   unsigned int count;
   struct REGEX_INTERNAL_State *s;
@@ -532,8 +535,9 @@ REGEX_INTERNAL_automaton_traverse (const struct REGEX_INTERNAL_Automaton *a,
   else
     s = start;
 
-  automaton_state_traverse (s, marks, &count, check, check_cls, action,
-                            action_cls);
+  automaton_state_traverse (s, marks, &count,
+                            check, check_cls,
+                            action, action_cls);
 }
 
 
@@ -559,7 +563,7 @@ struct StringBuffer
   size_t slen;
 
   /**
-   * Number of bytes allocated for 'sbuf'
+   * Number of bytes allocated for @e sbuf
    */
   unsigned int blen;
 
@@ -570,7 +574,7 @@ struct StringBuffer
 
   /**
    * If this entry is part of the last/current generation array,
-   * this flag is GNUNET_YES if the last and current generation are
+   * this flag is #GNUNET_YES if the last and current generation are
    * identical (and thus copying is unnecessary if the value didn't
    * change).  This is used in an optimization that improves
    * performance by about 1% --- if we use int16_t here.  With just
@@ -604,7 +608,7 @@ sb_nullstrcmp (const struct StringBuffer *s1,
     return -1;
   return memcmp (s1->sbuf, s2->sbuf, s1->slen);
 }
-	
+
 
 /**
  * Compare two strings for equality.
@@ -622,7 +626,7 @@ sb_strcmp (const struct StringBuffer *s1,
     return -1;
   return memcmp (s1->sbuf, s2->sbuf, s1->slen);
 }
-	
+
 
 /**
  * Reallocate the buffer of 'ret' to fit 'nlen' characters;
@@ -669,7 +673,7 @@ sb_append (struct StringBuffer *ret,
 	  sarg->slen);
   ret->slen += sarg->slen;
 }
-	
+
 
 /**
  * Append a C string.
@@ -693,7 +697,7 @@ sb_append_cstr (struct StringBuffer *ret,
 	  cstr_len);
   ret->slen += cstr_len;
 }
-	
+
 
 /**
  * Wrap a string buffer, that is, set ret to the format string
@@ -854,7 +858,7 @@ sb_free (struct StringBuffer *sb)
 static void
 sb_strdup (struct StringBuffer *out,
 	   const struct StringBuffer *in)
-	
+
 {
   out->null_flag = in->null_flag;
   if (GNUNET_YES == out->null_flag)
@@ -900,12 +904,12 @@ sb_strdup_cstr (struct StringBuffer *out,
 
 
 /**
- * Check if the given string 'str' needs parentheses around it when
+ * Check if the given string @a str needs parentheses around it when
  * using it to generate a regex.
  *
  * @param str string
  *
- * @return GNUNET_YES if parentheses are needed, GNUNET_NO otherwise
+ * @return #GNUNET_YES if parentheses are needed, #GNUNET_NO otherwise
  */
 static int
 needs_parentheses (const struct StringBuffer *str)
@@ -949,9 +953,9 @@ needs_parentheses (const struct StringBuffer *str)
 
 
 /**
- * Remove parentheses surrounding string 'str'.
+ * Remove parentheses surrounding string @a str.
  * Example: "(a)" becomes "a", "(a|b)|(a|c)" stays the same.
- * You need to GNUNET_free the returned string.
+ * You need to #GNUNET_free() the returned string.
  *
  * @param str string, modified to contain a
  * @return string without surrounding parentheses, string 'str' if no preceding
@@ -1799,8 +1803,10 @@ dfa_state_create (struct REGEX_INTERNAL_Context *ctx,
   for (i = 0; i < nfa_states->off; i++)
   {
     cstate = nfa_states->states[i];
-    GNUNET_snprintf (pos, pos - s->name + len,
-		     "%i,", cstate->id);
+    GNUNET_snprintf (pos,
+                     pos - s->name + len,
+		     "%i,",
+                     cstate->id);
     pos += strlen (pos);
 
     /* Add a transition for each distinct label to NULL state */
@@ -1867,16 +1873,18 @@ dfa_move (struct REGEX_INTERNAL_State **s, const char *str)
 
 
 /**
- * Set the given state 'marked' to GNUNET_YES. Used by the
- * 'dfa_remove_unreachable_states' function to detect unreachable states in the
+ * Set the given state 'marked' to #GNUNET_YES. Used by the
+ * #dfa_remove_unreachable_states() function to detect unreachable states in the
  * automaton.
  *
  * @param cls closure, not used.
  * @param count count, not used.
- * @param s state where the marked attribute will be set to GNUNET_YES.
+ * @param s state where the marked attribute will be set to #GNUNET_YES.
  */
 static void
-mark_states (void *cls, const unsigned int count, struct REGEX_INTERNAL_State *s)
+mark_states (void *cls,
+             const unsigned int count,
+             struct REGEX_INTERNAL_State *s)
 {
   s->marked = GNUNET_YES;
 }
@@ -1958,7 +1966,7 @@ dfa_remove_dead_states (struct REGEX_INTERNAL_Automaton *a)
  *
  * @param ctx context
  * @param a DFA automaton
- * @return GNUNET_OK on success
+ * @return #GNUNET_OK on success
  */
 static int
 dfa_merge_nondistinguishable_states (struct REGEX_INTERNAL_Context *ctx,
@@ -3115,10 +3123,11 @@ REGEX_INTERNAL_automaton_destroy (struct REGEX_INTERNAL_Automaton *a)
  * @param a automaton, type must be DFA
  * @param string string that should be evaluated
  *
- * @return 0 if string matches, non 0 otherwise
+ * @return 0 if string matches, non-0 otherwise
  */
 static int
-evaluate_dfa (struct REGEX_INTERNAL_Automaton *a, const char *string)
+evaluate_dfa (struct REGEX_INTERNAL_Automaton *a,
+              const char *string)
 {
   const char *strp;
   struct REGEX_INTERNAL_State *s;
@@ -3157,11 +3166,11 @@ evaluate_dfa (struct REGEX_INTERNAL_Automaton *a, const char *string)
  *
  * @param a automaton, type must be NFA
  * @param string string that should be evaluated
- *
- * @return 0 if string matches, non 0 otherwise
+ * @return 0 if string matches, non-0 otherwise
  */
 static int
-evaluate_nfa (struct REGEX_INTERNAL_Automaton *a, const char *string)
+evaluate_nfa (struct REGEX_INTERNAL_Automaton *a,
+              const char *string)
 {
   const char *strp;
   char str[2];
@@ -3215,15 +3224,15 @@ evaluate_nfa (struct REGEX_INTERNAL_Automaton *a, const char *string)
 
 
 /**
- * Evaluates the given 'string' against the given compiled regex
+ * Evaluates the given @a string against the given compiled regex @a a
  *
  * @param a automaton
  * @param string string to check
- *
- * @return 0 if string matches, non 0 otherwise
+ * @return 0 if string matches, non-0 otherwise
  */
 int
-REGEX_INTERNAL_eval (struct REGEX_INTERNAL_Automaton *a, const char *string)
+REGEX_INTERNAL_eval (struct REGEX_INTERNAL_Automaton *a,
+                     const char *string)
 {
   int result;
 
@@ -3292,19 +3301,19 @@ REGEX_INTERNAL_get_transition_count (struct REGEX_INTERNAL_Automaton *a)
 
 
 /**
- * Get the first key for the given 'input_string'. This hashes the first x bits
- * of the 'input_string'.
+ * Get the first key for the given @a input_string. This hashes the first x bits
+ * of the @a input_string.
  *
  * @param input_string string.
- * @param string_len length of the 'input_string'.
+ * @param string_len length of the @a input_string.
  * @param key pointer to where to write the hash code.
- *
- * @return number of bits of 'input_string' that have been consumed
+ * @return number of bits of @a input_string that have been consumed
  *         to construct the key
  */
 size_t
-REGEX_INTERNAL_get_first_key (const char *input_string, size_t string_len,
-                            struct GNUNET_HashCode * key)
+REGEX_INTERNAL_get_first_key (const char *input_string,
+                              size_t string_len,
+                              struct GNUNET_HashCode *key)
 {
   size_t size;
 
@@ -3330,12 +3339,15 @@ REGEX_INTERNAL_get_first_key (const char *input_string, size_t string_len,
  * @param consumed_string string consumed by traversing the graph till this state.
  * @param state current state of the automaton.
  * @param iterator iterator function called for each edge.
- * @param iterator_cls closure for the iterator function.
+ * @param iterator_cls closure for the @a iterator function.
  */
 static void
-iterate_initial_edge (const unsigned int min_len, const unsigned int max_len,
-                      char *consumed_string, struct REGEX_INTERNAL_State *state,
-                      REGEX_INTERNAL_KeyIterator iterator, void *iterator_cls)
+iterate_initial_edge (unsigned int min_len,
+                      unsigned int max_len,
+                      char *consumed_string,
+                      struct REGEX_INTERNAL_State *state,
+                      REGEX_INTERNAL_KeyIterator iterator,
+                      void *iterator_cls)
 {
   char *temp;
   struct REGEX_INTERNAL_Transition *t;
@@ -3351,21 +3363,36 @@ iterate_initial_edge (const unsigned int min_len, const unsigned int max_len,
   else
     cur_len = 0;
 
-  if ((cur_len >= min_len || GNUNET_YES == state->accepting) && cur_len > 0 &&
-      NULL != consumed_string)
+  if ( ( (cur_len >= min_len) ||
+         (GNUNET_YES == state->accepting) ) &&
+       (cur_len > 0) &&
+       (NULL != consumed_string) )
   {
     if (cur_len <= max_len)
     {
-      if (state->proof != NULL && 0 != strcmp (consumed_string, state->proof))
+      if ( (NULL != state->proof) &&
+           (0 != strcmp (consumed_string,
+                         state->proof)) )
       {
         (void) state_get_edges (state, edges);
-        GNUNET_CRYPTO_hash (consumed_string, strlen (consumed_string), &hash);
-        iterator (iterator_cls, &hash, consumed_string, state->accepting,
+        GNUNET_CRYPTO_hash (consumed_string,
+                            strlen (consumed_string),
+                            &hash);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Start state for string `%s' is %s\n",
+                    consumed_string,
+                    GNUNET_h2s (&hash));
+        iterator (iterator_cls,
+                  &hash,
+                  consumed_string,
+                  state->accepting,
                   num_edges, edges);
       }
 
-      if (GNUNET_YES == state->accepting && cur_len > 1 &&
-          state->transition_count < 1 && cur_len < max_len)
+      if ( (GNUNET_YES == state->accepting) &&
+           (cur_len > 1) &&
+           (state->transition_count < 1) &&
+           (cur_len < max_len) )
       {
         /* Special case for regex consisting of just a string that is shorter than
          * max_len */
@@ -3373,8 +3400,18 @@ iterate_initial_edge (const unsigned int min_len, const unsigned int max_len,
         edge[0].destination = state->hash;
         temp = GNUNET_strdup (consumed_string);
         temp[cur_len - 1] = '\0';
-        GNUNET_CRYPTO_hash (temp, cur_len - 1, &hash_new);
-        iterator (iterator_cls, &hash_new, temp, GNUNET_NO, 1, edge);
+        GNUNET_CRYPTO_hash (temp,
+                            cur_len - 1,
+                            &hash_new);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Start state for short string `%s' is %s\n",
+                    temp,
+                    GNUNET_h2s (&hash_new));
+        iterator (iterator_cls,
+                  &hash_new,
+                  temp,
+                  GNUNET_NO, 1,
+                  edge);
         GNUNET_free (temp);
       }
     }
@@ -3386,7 +3423,17 @@ iterate_initial_edge (const unsigned int min_len, const unsigned int max_len,
       temp = GNUNET_strdup (consumed_string);
       temp[max_len] = '\0';
       GNUNET_CRYPTO_hash (temp, max_len, &hash);
-      iterator (iterator_cls, &hash, temp, GNUNET_NO, 1, edge);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Start state at split edge `%s'-`%s` is %s\n",
+                  temp,
+                  edge[0].label,
+                  GNUNET_h2s (&hash_new));
+      iterator (iterator_cls,
+                &hash,
+                temp,
+                GNUNET_NO,
+                1,
+                edge);
       GNUNET_free (temp);
     }
   }
@@ -3395,12 +3442,27 @@ iterate_initial_edge (const unsigned int min_len, const unsigned int max_len,
   {
     for (t = state->transitions_head; NULL != t; t = t->next)
     {
+      if (NULL != strchr (t->label,
+                          (int) '.'))
+      {
+        /* Wildcards not allowed during starting states */
+        GNUNET_break (0);
+        continue;
+      }
       if (NULL != consumed_string)
-        GNUNET_asprintf (&temp, "%s%s", consumed_string, t->label);
+        GNUNET_asprintf (&temp,
+                         "%s%s",
+                         consumed_string,
+                         t->label);
       else
-        GNUNET_asprintf (&temp, "%s", t->label);
-
-      iterate_initial_edge (min_len, max_len, temp, t->to_state, iterator,
+        GNUNET_asprintf (&temp,
+                         "%s",
+                         t->label);
+      iterate_initial_edge (min_len,
+                            max_len,
+                            temp,
+                            t->to_state,
+                            iterator,
                             iterator_cls);
       GNUNET_free (temp);
     }
@@ -3423,6 +3485,14 @@ REGEX_INTERNAL_iterate_all_edges (struct REGEX_INTERNAL_Automaton *a,
 {
   struct REGEX_INTERNAL_State *s;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Iterating over starting edges\n");
+  iterate_initial_edge (GNUNET_REGEX_INITIAL_BYTES,
+                        GNUNET_REGEX_INITIAL_BYTES,
+                        NULL, a->start,
+                        iterator, iterator_cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Iterating over DFA edges\n");
   for (s = a->states_head; NULL != s; s = s->next)
   {
     struct REGEX_BLOCK_Edge edges[s->transition_count];
@@ -3431,18 +3501,20 @@ REGEX_INTERNAL_iterate_all_edges (struct REGEX_INTERNAL_Automaton *a,
     num_edges = state_get_edges (s, edges);
     if ( ( (NULL != s->proof) &&
            (0 < strlen (s->proof)) ) || s->accepting)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Creating DFA edges at `%s' under key %s\n",
+                  s->proof,
+                  GNUNET_h2s (&s->hash));
       iterator (iterator_cls, &s->hash, s->proof,
                 s->accepting,
                 num_edges, edges);
+    }
     s->marked = GNUNET_NO;
   }
-
-  iterate_initial_edge (GNUNET_REGEX_INITIAL_BYTES,
-                        GNUNET_REGEX_INITIAL_BYTES,
-                        NULL, a->start,
-                        iterator, iterator_cls);
 }
 
+
 /**
  * Struct to hold all the relevant state information in the HashMap.
  *
diff --git a/src/regex/regex_internal_dht.c b/src/regex/regex_internal_dht.c
index 7fa15ba45a..f11a39589f 100644
--- a/src/regex/regex_internal_dht.c
+++ b/src/regex/regex_internal_dht.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet
-     Copyright (C) 2012 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2012, 2015 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -34,8 +34,19 @@
 
 #define LOG(kind,...) GNUNET_log_from (kind,"regex-dht",__VA_ARGS__)
 
+/**
+ * DHT replication level to use.
+ */
 #define DHT_REPLICATION 5
+
+/**
+ * DHT record lifetime to use.
+ */
 #define DHT_TTL         GNUNET_TIME_UNIT_HOURS
+
+/**
+ * DHT options to set.
+ */
 #define DHT_OPT         GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE
 
 
@@ -57,7 +68,7 @@ struct REGEX_INTERNAL_Announcement
   /**
    * Automaton representation of the regex (expensive to build).
    */
-  struct REGEX_INTERNAL_Automaton* dfa;
+  struct REGEX_INTERNAL_Automaton *dfa;
 
   /**
    * Our private key.
@@ -77,7 +88,7 @@ struct REGEX_INTERNAL_Announcement
  * @param cls closure.
  * @param key hash for current state.
  * @param proof proof for current state.
- * @param accepting GNUNET_YES if this is an accepting state, GNUNET_NO if not.
+ * @param accepting #GNUNET_YES if this is an accepting state, #GNUNET_NO if not.
  * @param num_edges number of edges leaving current state.
  * @param edges edges leaving current state.
  */
@@ -95,17 +106,17 @@ regex_iterator (void *cls,
   unsigned int i;
 
   LOG (GNUNET_ERROR_TYPE_INFO,
-       "DHT PUT for state %s with proof `%s' and %u edges\n",
+       "DHT PUT for state %s with proof `%s' and %u edges:\n",
        GNUNET_h2s (key),
        proof,
        num_edges);
   for (i = 0; i < num_edges; i++)
   {
     LOG (GNUNET_ERROR_TYPE_INFO,
-         "  edge %s towards %s (%s)\n",
+         "Edge %u `%s' towards %s\n",
+         i,
          edges[i].label,
-         GNUNET_h2s (&edges[i].destination),
-         proof);
+         GNUNET_h2s (&edges[i].destination));
   }
   if (GNUNET_YES == accepting)
   {
@@ -156,9 +167,11 @@ regex_iterator (void *cls,
                   GNUNET_TIME_relative_to_absolute (DHT_TTL),
                   DHT_TTL,
                   NULL, NULL);
-  GNUNET_STATISTICS_update (h->stats, "# regex blocks stored",
+  GNUNET_STATISTICS_update (h->stats,
+                            "# regex blocks stored",
                             1, GNUNET_NO);
-  GNUNET_STATISTICS_update (h->stats, "# regex block bytes stored",
+  GNUNET_STATISTICS_update (h->stats,
+                            "# regex block bytes stored",
                             size, GNUNET_NO);
   GNUNET_free (block);
 }
@@ -166,16 +179,15 @@ regex_iterator (void *cls,
 
 /**
  * Announce a regular expression: put all states of the automaton in the DHT.
- * Does not free resources, must call REGEX_INTERNAL_announce_cancel for that.
+ * Does not free resources, must call #REGEX_INTERNAL_announce_cancel() for that.
  *
  * @param dht An existing and valid DHT service handle. CANNOT be NULL.
  * @param priv our private key, must remain valid until the announcement is cancelled
  * @param regex Regular expression to announce.
  * @param compression How many characters per edge can we squeeze?
  * @param stats Optional statistics handle to report usage. Can be NULL.
- *
  * @return Handle to reuse o free cached resources.
- *         Must be freed by calling REGEX_INTERNAL_announce_cancel.
+ *         Must be freed by calling #REGEX_INTERNAL_announce_cancel().
  */
 struct REGEX_INTERNAL_Announcement *
 REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht,
@@ -202,7 +214,7 @@ REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht,
  * Announce again a regular expression previously announced.
  * Does use caching to speed up process.
  *
- * @param h Handle returned by a previous REGEX_INTERNAL_announce call.
+ * @param h Handle returned by a previous #REGEX_INTERNAL_announce call().
  */
 void
 REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
@@ -211,7 +223,9 @@ REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
   LOG (GNUNET_ERROR_TYPE_INFO,
        "REGEX_INTERNAL_reannounce: %s\n",
        h->regex);
-  REGEX_INTERNAL_iterate_reachable_edges (h->dfa, &regex_iterator, h);
+  REGEX_INTERNAL_iterate_reachable_edges (h->dfa,
+                                          &regex_iterator,
+                                          h);
 }
 
 
@@ -219,7 +233,7 @@ REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
  * Clear all cached data used by a regex announce.
  * Does not close DHT connection.
  *
- * @param h Handle returned by a previous REGEX_INTERNAL_announce call.
+ * @param h Handle returned by a previous #REGEX_INTERNAL_announce() call.
  */
 void
 REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h)
diff --git a/src/regex/regex_internal_lib.h b/src/regex/regex_internal_lib.h
index 2703565fe6..81af08197c 100644
--- a/src/regex/regex_internal_lib.h
+++ b/src/regex/regex_internal_lib.h
@@ -61,11 +61,12 @@ struct REGEX_INTERNAL_Automaton;
  * @param max_path_len limit the path compression length to the
  *        given value. If set to 1, no path compression is applied. Set to 0 for
  *        maximal possible path compression (generally not desireable).
- * @return DFA, needs to be freed using REGEX_INTERNAL_automaton_destroy.
+ * @return DFA, needs to be freed using #REGEX_INTERNAL_automaton_destroy().
  */
 struct REGEX_INTERNAL_Automaton *
-REGEX_INTERNAL_construct_dfa (const char *regex, const size_t len,
-                            unsigned int max_path_len);
+REGEX_INTERNAL_construct_dfa (const char *regex,
+                              const size_t len,
+                              unsigned int max_path_len);
 
 
 /**
@@ -88,23 +89,23 @@ REGEX_INTERNAL_automaton_destroy (struct REGEX_INTERNAL_Automaton *a);
  */
 int
 REGEX_INTERNAL_eval (struct REGEX_INTERNAL_Automaton *a,
-                   const char *string);
+                     const char *string);
 
 
 /**
- * Get the first key for the given 'input_string'. This hashes
- * the first x bits of the 'input_string'.
+ * Get the first key for the given @a input_string. This hashes
+ * the first x bits of the @a input_string.
  *
  * @param input_string string.
- * @param string_len length of the 'input_string'.
+ * @param string_len length of the @a input_string.
  * @param key pointer to where to write the hash code.
- *
- * @return number of bits of 'input_string' that have been consumed
+ * @return number of bits of @a input_string that have been consumed
  *         to construct the key
  */
 size_t
-REGEX_INTERNAL_get_first_key (const char *input_string, size_t string_len,
-                            struct GNUNET_HashCode * key);
+REGEX_INTERNAL_get_first_key (const char *input_string,
+                              size_t string_len,
+                              struct GNUNET_HashCode * key);
 
 
 /**
@@ -113,16 +114,17 @@ REGEX_INTERNAL_get_first_key (const char *input_string, size_t string_len,
  * @param cls closure.
  * @param key hash for current state.
  * @param proof proof for current state
- * @param accepting GNUNET_YES if this is an accepting state, GNUNET_NO if not.
+ * @param accepting #GNUNET_YES if this is an accepting state, #GNUNET_NO if not.
  * @param num_edges number of edges leaving current state.
  * @param edges edges leaving current state.
  */
-typedef void (*REGEX_INTERNAL_KeyIterator)(void *cls,
-                                         const struct GNUNET_HashCode *key,
-                                         const char *proof,
-                                         int accepting,
-                                         unsigned int num_edges,
-                                         const struct REGEX_BLOCK_Edge *edges);
+typedef void
+(*REGEX_INTERNAL_KeyIterator)(void *cls,
+                              const struct GNUNET_HashCode *key,
+                              const char *proof,
+                              int accepting,
+                              unsigned int num_edges,
+                              const struct REGEX_BLOCK_Edge *edges);
 
 
 /**
@@ -135,13 +137,13 @@ typedef void (*REGEX_INTERNAL_KeyIterator)(void *cls,
  */
 void
 REGEX_INTERNAL_iterate_all_edges (struct REGEX_INTERNAL_Automaton *a,
-                                REGEX_INTERNAL_KeyIterator iterator,
-                                void *iterator_cls);
+                                  REGEX_INTERNAL_KeyIterator iterator,
+                                  void *iterator_cls);
 
 
 /**
  * Iterate over all edges of automaton 'a' that are reachable from a state with
- * a proof of at least GNUNET_REGEX_INITIAL_BYTES characters.
+ * a proof of at least #GNUNET_REGEX_INITIAL_BYTES characters.
  *
  * Call the iterator for each such edge.
  *
@@ -169,16 +171,15 @@ struct REGEX_INTERNAL_Search;
 
 /**
  * Announce a regular expression: put all states of the automaton in the DHT.
- * Does not free resources, must call REGEX_INTERNAL_announce_cancel for that.
+ * Does not free resources, must call #REGEX_INTERNAL_announce_cancel() for that.
  *
  * @param dht An existing and valid DHT service handle. CANNOT be NULL.
  * @param priv our private key, must remain valid until the announcement is cancelled
  * @param regex Regular expression to announce.
  * @param compression How many characters per edge can we squeeze?
  * @param stats Optional statistics handle to report usage. Can be NULL.
- *
  * @return Handle to reuse o free cached resources.
- *         Must be freed by calling REGEX_INTERNAL_announce_cancel.
+ *         Must be freed by calling #REGEX_INTERNAL_announce_cancel().
  */
 struct REGEX_INTERNAL_Announcement *
 REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht,
@@ -192,7 +193,7 @@ REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht,
  * Announce again a regular expression previously announced.
  * Does use caching to speed up process.
  *
- * @param h Handle returned by a previous REGEX_INTERNAL_announce call.
+ * @param h Handle returned by a previous #REGEX_INTERNAL_announce() call.
  */
 void
 REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h);
@@ -202,7 +203,7 @@ REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h);
  * Clear all cached data used by a regex announce.
  * Does not close DHT connection.
  *
- * @param h Handle returned by a previous REGEX_INTERNAL_announce call.
+ * @param h Handle returned by a previous #REGEX_INTERNAL_announce() call.
  */
 void
 REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h);
@@ -211,24 +212,25 @@ REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h);
 /**
  * Search callback function.
  *
- * @param cls Closure provided in REGEX_INTERNAL_search.
+ * @param cls Closure provided in #REGEX_INTERNAL_search().
  * @param id Peer providing a regex that matches the string.
  * @param get_path Path of the get request.
- * @param get_path_length Lenght of get_path.
+ * @param get_path_length Length of @a get_path.
  * @param put_path Path of the put request.
- * @param put_path_length Length of the put_path.
+ * @param put_path_length Length of the @a put_path.
  */
-typedef void (*REGEX_INTERNAL_Found)(void *cls,
-                                   const struct GNUNET_PeerIdentity *id,
-                                   const struct GNUNET_PeerIdentity *get_path,
-                                   unsigned int get_path_length,
-                                   const struct GNUNET_PeerIdentity *put_path,
-                                   unsigned int put_path_length);
+typedef void
+(*REGEX_INTERNAL_Found)(void *cls,
+                        const struct GNUNET_PeerIdentity *id,
+                        const struct GNUNET_PeerIdentity *get_path,
+                        unsigned int get_path_length,
+                        const struct GNUNET_PeerIdentity *put_path,
+                        unsigned int put_path_length);
 
 
 /**
  * Search for a peer offering a regex matching certain string in the DHT.
- * The search runs until REGEX_INTERNAL_search_cancel is called, even if results
+ * The search runs until #REGEX_INTERNAL_search_cancel() is called, even if results
  * are returned.
  *
  * @param dht An existing and valid DHT service handle.
@@ -236,22 +238,21 @@ typedef void (*REGEX_INTERNAL_Found)(void *cls,
  * @param callback Callback for found peers.
  * @param callback_cls Closure for @c callback.
  * @param stats Optional statistics handle to report usage. Can be NULL.
- *
  * @return Handle to stop search and free resources.
- *         Must be freed by calling REGEX_INTERNAL_search_cancel.
+ *         Must be freed by calling #REGEX_INTERNAL_search_cancel().
  */
 struct REGEX_INTERNAL_Search *
 REGEX_INTERNAL_search (struct GNUNET_DHT_Handle *dht,
-                     const char *string,
-                     REGEX_INTERNAL_Found callback,
-                     void *callback_cls,
-                     struct GNUNET_STATISTICS_Handle *stats);
+                       const char *string,
+                       REGEX_INTERNAL_Found callback,
+                       void *callback_cls,
+                       struct GNUNET_STATISTICS_Handle *stats);
 
 /**
- * Stop search and free all data used by a REGEX_INTERNAL_search call.
+ * Stop search and free all data used by a #REGEX_INTERNAL_search() call.
  * Does not close DHT connection.
  *
- * @param h Handle returned by a previous REGEX_INTERNAL_search call.
+ * @param h Handle returned by a previous #REGEX_INTERNAL_search() call.
  */
 void
 REGEX_INTERNAL_search_cancel (struct REGEX_INTERNAL_Search *h);
diff --git a/src/regex/test_regex_integration.c b/src/regex/test_regex_integration.c
index b28ab15d0c..0cb177fcc8 100644
--- a/src/regex/test_regex_integration.c
+++ b/src/regex/test_regex_integration.c
@@ -85,7 +85,7 @@ end_badly ()
 /**
  * Search callback function, invoked for every result that was found.
  *
- * @param cls Closure provided in GNUNET_REGEX_search.
+ * @param cls Closure provided in #GNUNET_REGEX_search().
  * @param id Peer providing a regex that matches the string.
  * @param get_path Path of the get request.
  * @param get_path_length Length of @a get_path.
@@ -103,9 +103,9 @@ found_cb (void *cls,
   const char *str = cls;
   static int found;
 
-  fprintf (stderr,
-           "IPv%s-exit found\n",
-           str);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "IPv%s-exit found\n",
+              str);
   if (0 == strcmp (str, "4"))
     found |= 4;
   if (0 == strcmp (str, "6"))