1 files changed, 331 insertions, 326 deletions

diff --git a/src/regex/regex_internal_dht.c b/src/regex/regex_internal_dht.c
index 611fb0a23..3cf48f3c2 100644
--- a/src/regex/regex_internal_dht.c
+++ b/src/regex/regex_internal_dht.c
@@ -32,7 +32,7 @@
 #include "gnunet_signatures.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "regex-dht", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "regex-dht", __VA_ARGS__)
 
 /**
  * DHT replication level to use.
@@ -53,7 +53,8 @@
 /**
  * Handle to store cached data about a regex announce.
  */
-struct REGEX_INTERNAL_Announcement {
+struct REGEX_INTERNAL_Announcement
+{
   /**
    * DHT handle to use, must be initialized externally.
    */
@@ -92,92 +93,93 @@ struct REGEX_INTERNAL_Announcement {
  * @param edges edges leaving current state.
  */
 static void
-regex_iterator(void *cls,
-               const struct GNUNET_HashCode *key,
-               const char *proof,
-               int accepting,
-               unsigned int num_edges,
-               const struct REGEX_BLOCK_Edge *edges)
+regex_iterator (void *cls,
+                const struct GNUNET_HashCode *key,
+                const char *proof,
+                int accepting,
+                unsigned int num_edges,
+                const struct REGEX_BLOCK_Edge *edges)
 {
   struct REGEX_INTERNAL_Announcement *h = cls;
   struct RegexBlock *block;
   size_t size;
   unsigned int i;
 
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "DHT PUT for state %s with proof `%s' and %u edges:\n",
-      GNUNET_h2s(key),
-      proof,
-      num_edges);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "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 %u `%s' towards %s\n",
-          i,
-          edges[i].label,
-          GNUNET_h2s(&edges[i].destination));
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Edge %u `%s' towards %s\n",
+         i,
+         edges[i].label,
+         GNUNET_h2s (&edges[i].destination));
+  }
   if (GNUNET_YES == accepting)
-    {
-      struct RegexAcceptBlock ab;
-
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "State %s is accepting, putting own id\n",
-          GNUNET_h2s(key));
-      size = sizeof(struct RegexAcceptBlock);
-      ab.purpose.size = ntohl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) +
-                              sizeof(struct GNUNET_TIME_AbsoluteNBO) +
-                              sizeof(struct GNUNET_HashCode));
-      ab.purpose.purpose = ntohl(GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT);
-      ab.expiration_time = GNUNET_TIME_absolute_hton(GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_DHT_MAX_EXPIRATION));
-      ab.key = *key;
-      GNUNET_CRYPTO_eddsa_key_get_public(h->priv,
-                                         &ab.peer.public_key);
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CRYPTO_eddsa_sign(h->priv,
+  {
+    struct RegexAcceptBlock ab;
+
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "State %s is accepting, putting own id\n",
+         GNUNET_h2s (key));
+    size = sizeof(struct RegexAcceptBlock);
+    ab.purpose.size = ntohl (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+                             + sizeof(struct GNUNET_TIME_AbsoluteNBO)
+                             + sizeof(struct GNUNET_HashCode));
+    ab.purpose.purpose = ntohl (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT);
+    ab.expiration_time = GNUNET_TIME_absolute_hton (
+      GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_DHT_MAX_EXPIRATION));
+    ab.key = *key;
+    GNUNET_CRYPTO_eddsa_key_get_public (h->priv,
+                                        &ab.peer.public_key);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_eddsa_sign (h->priv,
                                              &ab.purpose,
                                              &ab.signature));
 
-      GNUNET_STATISTICS_update(h->stats, "# regex accepting blocks stored",
-                               1, GNUNET_NO);
-      GNUNET_STATISTICS_update(h->stats, "# regex accepting block bytes stored",
-                               sizeof(struct RegexAcceptBlock), GNUNET_NO);
-      (void)
-      GNUNET_DHT_put(h->dht, key,
-                     DHT_REPLICATION,
-                     DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
-                     GNUNET_BLOCK_TYPE_REGEX_ACCEPT,
-                     size,
-                     &ab,
-                     GNUNET_TIME_relative_to_absolute(DHT_TTL),
-                     NULL, NULL);
-    }
-  block = REGEX_BLOCK_create(proof,
-                             num_edges,
-                             edges,
-                             accepting,
-                             &size);
+    GNUNET_STATISTICS_update (h->stats, "# regex accepting blocks stored",
+                              1, GNUNET_NO);
+    GNUNET_STATISTICS_update (h->stats, "# regex accepting block bytes stored",
+                              sizeof(struct RegexAcceptBlock), GNUNET_NO);
+    (void)
+    GNUNET_DHT_put (h->dht, key,
+                    DHT_REPLICATION,
+                    DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
+                    GNUNET_BLOCK_TYPE_REGEX_ACCEPT,
+                    size,
+                    &ab,
+                    GNUNET_TIME_relative_to_absolute (DHT_TTL),
+                    NULL, NULL);
+  }
+  block = REGEX_BLOCK_create (proof,
+                              num_edges,
+                              edges,
+                              accepting,
+                              &size);
   if (NULL == block)
     return;
-  (void)GNUNET_DHT_put(h->dht,
-                       key,
-                       DHT_REPLICATION,
-                       DHT_OPT,
-                       GNUNET_BLOCK_TYPE_REGEX,
-                       size,
-                       block,
-                       GNUNET_TIME_relative_to_absolute(DHT_TTL),
-                       NULL,
-                       NULL);
-  GNUNET_STATISTICS_update(h->stats,
-                           "# regex blocks stored",
-                           1,
-                           GNUNET_NO);
-  GNUNET_STATISTICS_update(h->stats,
-                           "# regex block bytes stored",
-                           size,
-                           GNUNET_NO);
-  GNUNET_free(block);
+  (void) GNUNET_DHT_put (h->dht,
+                         key,
+                         DHT_REPLICATION,
+                         DHT_OPT,
+                         GNUNET_BLOCK_TYPE_REGEX,
+                         size,
+                         block,
+                         GNUNET_TIME_relative_to_absolute (DHT_TTL),
+                         NULL,
+                         NULL);
+  GNUNET_STATISTICS_update (h->stats,
+                            "# regex blocks stored",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (h->stats,
+                            "# regex block bytes stored",
+                            size,
+                            GNUNET_NO);
+  GNUNET_free (block);
 }
 
 
@@ -194,22 +196,22 @@ regex_iterator(void *cls,
  *         Must be freed by calling #REGEX_INTERNAL_announce_cancel().
  */
 struct REGEX_INTERNAL_Announcement *
-REGEX_INTERNAL_announce(struct GNUNET_DHT_Handle *dht,
-                        const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
-                        const char *regex,
-                        uint16_t compression,
-                        struct GNUNET_STATISTICS_Handle *stats)
+REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht,
+                         const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
+                         const char *regex,
+                         uint16_t compression,
+                         struct GNUNET_STATISTICS_Handle *stats)
 {
   struct REGEX_INTERNAL_Announcement *h;
 
-  GNUNET_assert(NULL != dht);
-  h = GNUNET_new(struct REGEX_INTERNAL_Announcement);
+  GNUNET_assert (NULL != dht);
+  h = GNUNET_new (struct REGEX_INTERNAL_Announcement);
   h->regex = regex;
   h->dht = dht;
   h->stats = stats;
   h->priv = priv;
-  h->dfa = REGEX_INTERNAL_construct_dfa(regex, strlen(regex), compression);
-  REGEX_INTERNAL_reannounce(h);
+  h->dfa = REGEX_INTERNAL_construct_dfa (regex, strlen (regex), compression);
+  REGEX_INTERNAL_reannounce (h);
   return h;
 }
 
@@ -221,15 +223,15 @@ REGEX_INTERNAL_announce(struct GNUNET_DHT_Handle *dht,
  * @param h Handle returned by a previous #REGEX_INTERNAL_announce call().
  */
 void
-REGEX_INTERNAL_reannounce(struct REGEX_INTERNAL_Announcement *h)
+REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
 {
-  GNUNET_assert(NULL != h->dfa);  /* make sure to call announce first */
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "REGEX_INTERNAL_reannounce: %s\n",
-      h->regex);
-  REGEX_INTERNAL_iterate_reachable_edges(h->dfa,
-                                         &regex_iterator,
-                                         h);
+  GNUNET_assert (NULL != h->dfa);  /* make sure to call announce first */
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "REGEX_INTERNAL_reannounce: %s\n",
+       h->regex);
+  REGEX_INTERNAL_iterate_reachable_edges (h->dfa,
+                                          &regex_iterator,
+                                          h);
 }
 
 
@@ -240,10 +242,10 @@ REGEX_INTERNAL_reannounce(struct REGEX_INTERNAL_Announcement *h)
  * @param h Handle returned by a previous #REGEX_INTERNAL_announce() call.
  */
 void
-REGEX_INTERNAL_announce_cancel(struct REGEX_INTERNAL_Announcement *h)
+REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h)
 {
-  REGEX_INTERNAL_automaton_destroy(h->dfa);
-  GNUNET_free(h);
+  REGEX_INTERNAL_automaton_destroy (h->dfa);
+  GNUNET_free (h);
 }
 
 
@@ -254,7 +256,8 @@ REGEX_INTERNAL_announce_cancel(struct REGEX_INTERNAL_Announcement *h)
  * Struct to keep state of running searches that have consumed a part of
  * the inital string.
  */
-struct RegexSearchContext {
+struct RegexSearchContext
+{
   /**
    * Part of the description already consumed by
    * this particular search branch.
@@ -282,7 +285,8 @@ struct RegexSearchContext {
 /**
  * Type of values in `dht_get_results`.
  */
-struct Result {
+struct Result
+{
   /**
    * Number of bytes in data.
    */
@@ -299,7 +303,8 @@ struct Result {
  * Struct to keep information of searches of services described by a regex
  * using a user-provided string service description.
  */
-struct REGEX_INTERNAL_Search {
+struct REGEX_INTERNAL_Search
+{
   /**
    * DHT handle to use, must be initialized externally.
    */
@@ -356,9 +361,9 @@ struct REGEX_INTERNAL_Search {
  * @param ctx Context of the search.
  */
 static void
-regex_next_edge(const struct RegexBlock *block,
-                size_t size,
-                struct RegexSearchContext *ctx);
+regex_next_edge (const struct RegexBlock *block,
+                 size_t size,
+                 struct RegexSearchContext *ctx);
 
 
 /**
@@ -377,33 +382,33 @@ regex_next_edge(const struct RegexBlock *block,
  * @param data Pointer to the result data.
  */
 static void
-dht_get_string_accept_handler(void *cls, struct GNUNET_TIME_Absolute exp,
-                              const struct GNUNET_HashCode *key,
-                              const struct GNUNET_PeerIdentity *get_path,
-                              unsigned int get_path_length,
-                              const struct GNUNET_PeerIdentity *put_path,
-                              unsigned int put_path_length,
-                              enum GNUNET_BLOCK_Type type,
-                              size_t size, const void *data)
+dht_get_string_accept_handler (void *cls, struct GNUNET_TIME_Absolute exp,
+                               const struct GNUNET_HashCode *key,
+                               const struct GNUNET_PeerIdentity *get_path,
+                               unsigned int get_path_length,
+                               const struct GNUNET_PeerIdentity *put_path,
+                               unsigned int put_path_length,
+                               enum GNUNET_BLOCK_Type type,
+                               size_t size, const void *data)
 {
   const struct RegexAcceptBlock *block = data;
   struct RegexSearchContext *ctx = cls;
   struct REGEX_INTERNAL_Search *info = ctx->info;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Regex result accept for %s (key %s)\n",
-      info->description, GNUNET_h2s(key));
-
-  GNUNET_STATISTICS_update(info->stats,
-                           "# regex accepting blocks found",
-                           1, GNUNET_NO);
-  GNUNET_STATISTICS_update(info->stats,
-                           "# regex accepting block bytes found",
-                           size, GNUNET_NO);
-  info->callback(info->callback_cls,
-                 &block->peer,
-                 get_path, get_path_length,
-                 put_path, put_path_length);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Regex result accept for %s (key %s)\n",
+       info->description, GNUNET_h2s (key));
+
+  GNUNET_STATISTICS_update (info->stats,
+                            "# regex accepting blocks found",
+                            1, GNUNET_NO);
+  GNUNET_STATISTICS_update (info->stats,
+                            "# regex accepting block bytes found",
+                            size, GNUNET_NO);
+  info->callback (info->callback_cls,
+                  &block->peer,
+                  get_path, get_path_length,
+                  put_path, put_path_length);
 }
 
 
@@ -415,28 +420,28 @@ dht_get_string_accept_handler(void *cls, struct GNUNET_TIME_Absolute exp,
  * @param ctx Context containing info about the string, tunnel, etc.
  */
 static void
-regex_find_path(const struct GNUNET_HashCode *key,
-                struct RegexSearchContext *ctx)
+regex_find_path (const struct GNUNET_HashCode *key,
+                 struct RegexSearchContext *ctx)
 {
   struct GNUNET_DHT_GetHandle *get_h;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Accept state found, now searching for paths to %s\n",
-      GNUNET_h2s(key),
-      (unsigned int)ctx->position);
-  get_h = GNUNET_DHT_get_start(ctx->info->dht,     /* handle */
-                               GNUNET_BLOCK_TYPE_REGEX_ACCEPT,  /* type */
-                               key,      /* key to search */
-                               DHT_REPLICATION,  /* replication level */
-                               DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
-                               NULL, /* xquery */        // FIXME BLOOMFILTER
-                               0, /* xquery bits */      // FIXME BLOOMFILTER SIZE
-                               &dht_get_string_accept_handler, ctx);
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_CONTAINER_multihashmap_put(ctx->info->dht_get_handles,
-                                                 key,
-                                                 get_h,
-                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Accept state found, now searching for paths to %s\n",
+       GNUNET_h2s (key),
+       (unsigned int) ctx->position);
+  get_h = GNUNET_DHT_get_start (ctx->info->dht,     /* handle */
+                                GNUNET_BLOCK_TYPE_REGEX_ACCEPT, /* type */
+                                key,     /* key to search */
+                                DHT_REPLICATION, /* replication level */
+                                DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
+                                NULL, /* xquery */       // FIXME BLOOMFILTER
+                                0, /* xquery bits */     // FIXME BLOOMFILTER SIZE
+                                &dht_get_string_accept_handler, ctx);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap_put (ctx->info->dht_get_handles,
+                                                   key,
+                                                   get_h,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
 }
 
 
@@ -458,14 +463,14 @@ regex_find_path(const struct GNUNET_HashCode *key,
  * TODO: re-issue the request after certain time? cancel after X results?
  */
 static void
-dht_get_string_handler(void *cls, struct GNUNET_TIME_Absolute exp,
-                       const struct GNUNET_HashCode *key,
-                       const struct GNUNET_PeerIdentity *get_path,
-                       unsigned int get_path_length,
-                       const struct GNUNET_PeerIdentity *put_path,
-                       unsigned int put_path_length,
-                       enum GNUNET_BLOCK_Type type,
-                       size_t size, const void *data)
+dht_get_string_handler (void *cls, struct GNUNET_TIME_Absolute exp,
+                        const struct GNUNET_HashCode *key,
+                        const struct GNUNET_PeerIdentity *get_path,
+                        unsigned int get_path_length,
+                        const struct GNUNET_PeerIdentity *put_path,
+                        unsigned int put_path_length,
+                        enum GNUNET_BLOCK_Type type,
+                        size_t size, const void *data)
 {
   const struct RegexBlock *block = data;
   struct RegexSearchContext *ctx = cls;
@@ -473,32 +478,32 @@ dht_get_string_handler(void *cls, struct GNUNET_TIME_Absolute exp,
   size_t len;
   struct Result *copy;
 
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "DHT GET result for %s (%s)\n",
-      GNUNET_h2s(key), ctx->info->description);
-  copy = GNUNET_malloc(sizeof(struct Result) + size);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "DHT GET result for %s (%s)\n",
+       GNUNET_h2s (key), ctx->info->description);
+  copy = GNUNET_malloc (sizeof(struct Result) + size);
   copy->size = size;
   copy->data = &copy[1];
-  GNUNET_memcpy(&copy[1], block, size);
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_CONTAINER_multihashmap_put(info->dht_get_results,
-                                                 key, copy,
-                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  len = strlen(info->description);
+  GNUNET_memcpy (&copy[1], block, size);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap_put (info->dht_get_results,
+                                                   key, copy,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  len = strlen (info->description);
   if (len == ctx->position) // String processed
+  {
+    if (GNUNET_YES == GNUNET_BLOCK_is_accepting (block, size))
     {
-      if (GNUNET_YES == GNUNET_BLOCK_is_accepting(block, size))
-        {
-          regex_find_path(key, ctx);
-        }
-      else
-        {
-          LOG(GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
-          /* FIXME REGEX this block not successful, wait for more? start timeout? */
-        }
-      return;
+      regex_find_path (key, ctx);
     }
-  regex_next_edge(block, size, ctx);
+    else
+    {
+      LOG (GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
+      /* FIXME REGEX this block not successful, wait for more? start timeout? */
+    }
+    return;
+  }
+  regex_next_edge (block, size, ctx);
 }
 
 
@@ -511,32 +516,32 @@ dht_get_string_handler(void *cls, struct GNUNET_TIME_Absolute exp,
  * @return #GNUNET_YES: we should always continue to iterate.
  */
 static int
-regex_result_iterator(void *cls,
-                      const struct GNUNET_HashCode * key,
-                      void *value)
+regex_result_iterator (void *cls,
+                       const struct GNUNET_HashCode *key,
+                       void *value)
 {
   struct Result *result = value;
   const struct RegexBlock *block = result->data;
   struct RegexSearchContext *ctx = cls;
 
   if ((GNUNET_YES ==
-       GNUNET_BLOCK_is_accepting(block, result->size)) &&
-      (ctx->position == strlen(ctx->info->description)))
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Found accepting known block\n");
-      regex_find_path(key, ctx);
-      return GNUNET_YES; // We found an accept state!
-    }
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "* %u, %u, [%u]\n",
-      ctx->position,
-      strlen(ctx->info->description),
-      GNUNET_BLOCK_is_accepting(block, result->size));
-  regex_next_edge(block, result->size, ctx);
-
-  GNUNET_STATISTICS_update(ctx->info->stats, "# regex cadet blocks iterated",
-                           1, GNUNET_NO);
+       GNUNET_BLOCK_is_accepting (block, result->size)) &&
+      (ctx->position == strlen (ctx->info->description)))
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Found accepting known block\n");
+    regex_find_path (key, ctx);
+    return GNUNET_YES;   // We found an accept state!
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "* %u, %u, [%u]\n",
+       ctx->position,
+       strlen (ctx->info->description),
+       GNUNET_BLOCK_is_accepting (block, result->size));
+  regex_next_edge (block, result->size, ctx);
+
+  GNUNET_STATISTICS_update (ctx->info->stats, "# regex cadet blocks iterated",
+                            1, GNUNET_NO);
 
   return GNUNET_YES;
 }
@@ -552,43 +557,43 @@ regex_result_iterator(void *cls,
  * @return #GNUNET_YES if should keep iterating, #GNUNET_NO otherwise.
  */
 static int
-regex_edge_iterator(void *cls,
-                    const char *token,
-                    size_t len,
-                    const struct GNUNET_HashCode *key)
+regex_edge_iterator (void *cls,
+                     const char *token,
+                     size_t len,
+                     const struct GNUNET_HashCode *key)
 {
   struct RegexSearchContext *ctx = cls;
   struct REGEX_INTERNAL_Search *info = ctx->info;
   const char *current;
   size_t current_len;
 
-  GNUNET_STATISTICS_update(info->stats, "# regex edges iterated",
-                           1, GNUNET_NO);
+  GNUNET_STATISTICS_update (info->stats, "# regex edges iterated",
+                            1, GNUNET_NO);
   current = &info->description[ctx->position];
-  current_len = strlen(info->description) - ctx->position;
+  current_len = strlen (info->description) - ctx->position;
   if (len > current_len)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
-      return GNUNET_YES;
-    }
-  if (0 != strncmp(current, token, len))
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
-      return GNUNET_YES;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
+    return GNUNET_YES;
+  }
+  if (0 != strncmp (current, token, len))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
+    return GNUNET_YES;
+  }
 
   if (len > ctx->longest_match)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Token is longer, KEEP\n");
-      ctx->longest_match = len;
-      ctx->hash = *key;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is longer, KEEP\n");
+    ctx->longest_match = len;
+    ctx->hash = *key;
+  }
   else
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Token is not longer, IGNORE\n");
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is not longer, IGNORE\n");
+  }
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "*    End of regex edge iterator\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "*    End of regex edge iterator\n");
   return GNUNET_YES;
 }
 
@@ -601,9 +606,9 @@ regex_edge_iterator(void *cls,
  * @param ctx Context of the search.
  */
 static void
-regex_next_edge(const struct RegexBlock *block,
-                size_t size,
-                struct RegexSearchContext *ctx)
+regex_next_edge (const struct RegexBlock *block,
+                 size_t size,
+                 struct RegexSearchContext *ctx)
 {
   struct RegexSearchContext *new_ctx;
   struct REGEX_INTERNAL_Search *info = ctx->info;
@@ -612,69 +617,69 @@ regex_next_edge(const struct RegexBlock *block,
   const char *rest;
   int result;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
   /* Find the longest match for the current string position,
    * among tokens in the given block */
   ctx->longest_match = 0;
-  result = REGEX_BLOCK_iterate(block, size,
-                               &regex_edge_iterator, ctx);
-  GNUNET_break(GNUNET_OK == result);
+  result = REGEX_BLOCK_iterate (block, size,
+                                &regex_edge_iterator, ctx);
+  GNUNET_break (GNUNET_OK == result);
 
   /* Did anything match? */
   if (0 == ctx->longest_match)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "no match in block\n");
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "no match in block\n");
+    return;
+  }
 
   hash = &ctx->hash;
-  new_ctx = GNUNET_new(struct RegexSearchContext);
+  new_ctx = GNUNET_new (struct RegexSearchContext);
   new_ctx->info = info;
   new_ctx->position = ctx->position + ctx->longest_match;
-  GNUNET_array_append(info->contexts, info->n_contexts, new_ctx);
+  GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
 
   /* Check whether we already have a DHT GET running for it */
   if (GNUNET_YES ==
-      GNUNET_CONTAINER_multihashmap_contains(info->dht_get_handles, hash))
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "GET for %s running, END\n",
-          GNUNET_h2s(hash));
-      GNUNET_CONTAINER_multihashmap_get_multiple(info->dht_get_results,
-                                                 hash,
-                                                 &regex_result_iterator,
-                                                 new_ctx);
-      return; /* We are already looking for it */
-    }
-
-  GNUNET_STATISTICS_update(info->stats, "# regex nodes traversed",
-                           1, GNUNET_NO);
-
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Following edges at %s for offset %u in `%s'\n",
-      GNUNET_h2s(hash),
-      (unsigned int)ctx->position,
-      info->description);
+      GNUNET_CONTAINER_multihashmap_contains (info->dht_get_handles, hash))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "GET for %s running, END\n",
+         GNUNET_h2s (hash));
+    GNUNET_CONTAINER_multihashmap_get_multiple (info->dht_get_results,
+                                                hash,
+                                                &regex_result_iterator,
+                                                new_ctx);
+    return;   /* We are already looking for it */
+  }
+
+  GNUNET_STATISTICS_update (info->stats, "# regex nodes traversed",
+                            1, GNUNET_NO);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Following edges at %s for offset %u in `%s'\n",
+       GNUNET_h2s (hash),
+       (unsigned int) ctx->position,
+       info->description);
   rest = &new_ctx->info->description[new_ctx->position];
   get_h =
-    GNUNET_DHT_get_start(info->dht,       /* handle */
-                         GNUNET_BLOCK_TYPE_REGEX,    /* type */
-                         hash,        /* key to search */
-                         DHT_REPLICATION,    /* replication level */
-                         DHT_OPT,
-                         rest,    /* xquery */
-                         strlen(rest) + 1,         /* xquery bits */
-                         &dht_get_string_handler, new_ctx);
+    GNUNET_DHT_get_start (info->dht,       /* handle */
+                          GNUNET_BLOCK_TYPE_REGEX,   /* type */
+                          hash,       /* key to search */
+                          DHT_REPLICATION,   /* replication level */
+                          DHT_OPT,
+                          rest,   /* xquery */
+                          strlen (rest) + 1,       /* xquery bits */
+                          &dht_get_string_handler, new_ctx);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_multihashmap_put(info->dht_get_handles,
-                                        hash,
-                                        get_h,
-                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-    {
-      GNUNET_break(0);
-      return;
-    }
+      GNUNET_CONTAINER_multihashmap_put (info->dht_get_handles,
+                                         hash,
+                                         get_h,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+  {
+    GNUNET_break (0);
+    return;
+  }
 }
 
 
@@ -692,11 +697,11 @@ regex_next_edge(const struct RegexBlock *block,
  *         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)
+REGEX_INTERNAL_search (struct GNUNET_DHT_Handle *dht,
+                       const char *string,
+                       REGEX_INTERNAL_Found callback,
+                       void *callback_cls,
+                       struct GNUNET_STATISTICS_Handle *stats)
 {
   struct REGEX_INTERNAL_Search *h;
   struct GNUNET_DHT_GetHandle *get_h;
@@ -706,49 +711,49 @@ REGEX_INTERNAL_search(struct GNUNET_DHT_Handle *dht,
   size_t len;
 
   /* Initialize handle */
-  GNUNET_assert(NULL != dht);
-  GNUNET_assert(NULL != callback);
-  h = GNUNET_new(struct REGEX_INTERNAL_Search);
+  GNUNET_assert (NULL != dht);
+  GNUNET_assert (NULL != callback);
+  h = GNUNET_new (struct REGEX_INTERNAL_Search);
   h->dht = dht;
-  h->description = GNUNET_strdup(string);
+  h->description = GNUNET_strdup (string);
   h->callback = callback;
   h->callback_cls = callback_cls;
   h->stats = stats;
-  h->dht_get_handles = GNUNET_CONTAINER_multihashmap_create(32, GNUNET_NO);
-  h->dht_get_results = GNUNET_CONTAINER_multihashmap_create(32, GNUNET_NO);
+  h->dht_get_handles = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+  h->dht_get_results = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
 
   /* Initialize context */
-  len = strlen(string);
-  size = REGEX_INTERNAL_get_first_key(string, len, &key);
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "Initial key for `%s' is %s (based on `%.*s')\n",
-      string,
-      GNUNET_h2s(&key),
-      size,
-      string);
-  ctx = GNUNET_new(struct RegexSearchContext);
+  len = strlen (string);
+  size = REGEX_INTERNAL_get_first_key (string, len, &key);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Initial key for `%s' is %s (based on `%.*s')\n",
+       string,
+       GNUNET_h2s (&key),
+       size,
+       string);
+  ctx = GNUNET_new (struct RegexSearchContext);
   ctx->position = size;
   ctx->info = h;
-  GNUNET_array_append(h->contexts,
-                      h->n_contexts,
-                      ctx);
+  GNUNET_array_append (h->contexts,
+                       h->n_contexts,
+                       ctx);
   /* Start search in DHT */
-  get_h = GNUNET_DHT_get_start(h->dht,     /* handle */
-                               GNUNET_BLOCK_TYPE_REGEX,  /* type */
-                               &key,      /* key to search */
-                               DHT_REPLICATION,  /* replication level */
-                               DHT_OPT,
-                               &h->description[size],            /* xquery */
-                               // FIXME add BLOOMFILTER to exclude filtered peers
-                               len + 1 - size,                 /* xquery bits */
-                               // FIXME add BLOOMFILTER SIZE
-                               &dht_get_string_handler, ctx);
-  GNUNET_break(
+  get_h = GNUNET_DHT_get_start (h->dht,     /* handle */
+                                GNUNET_BLOCK_TYPE_REGEX, /* type */
+                                &key,     /* key to search */
+                                DHT_REPLICATION, /* replication level */
+                                DHT_OPT,
+                                &h->description[size],           /* xquery */
+                                // FIXME add BLOOMFILTER to exclude filtered peers
+                                len + 1 - size,                /* xquery bits */
+                                // FIXME add BLOOMFILTER SIZE
+                                &dht_get_string_handler, ctx);
+  GNUNET_break (
     GNUNET_OK ==
-    GNUNET_CONTAINER_multihashmap_put(h->dht_get_handles,
-                                      &key,
-                                      get_h,
-                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)
+    GNUNET_CONTAINER_multihashmap_put (h->dht_get_handles,
+                                       &key,
+                                       get_h,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)
     );
 
   return h;
@@ -766,13 +771,13 @@ REGEX_INTERNAL_search(struct GNUNET_DHT_Handle *dht,
  *         #GNUNET_NO if not.
  */
 static int
-regex_cancel_dht_get(void *cls,
-                     const struct GNUNET_HashCode * key,
-                     void *value)
+regex_cancel_dht_get (void *cls,
+                      const struct GNUNET_HashCode *key,
+                      void *value)
 {
   struct GNUNET_DHT_GetHandle *h = value;
 
-  GNUNET_DHT_get_stop(h);
+  GNUNET_DHT_get_stop (h);
   return GNUNET_YES;
 }
 
@@ -788,11 +793,11 @@ regex_cancel_dht_get(void *cls,
  *         #GNUNET_NO if not.
  */
 static int
-regex_free_result(void *cls,
-                  const struct GNUNET_HashCode * key,
-                  void *value)
+regex_free_result (void *cls,
+                   const struct GNUNET_HashCode *key,
+                   void *value)
 {
-  GNUNET_free(value);
+  GNUNET_free (value);
   return GNUNET_YES;
 }
 
@@ -803,24 +808,24 @@ regex_free_result(void *cls,
  * @param h the search context.
  */
 void
-REGEX_INTERNAL_search_cancel(struct REGEX_INTERNAL_Search *h)
+REGEX_INTERNAL_search_cancel (struct REGEX_INTERNAL_Search *h)
 {
   unsigned int i;
 
-  GNUNET_free(h->description);
-  GNUNET_CONTAINER_multihashmap_iterate(h->dht_get_handles,
-                                        &regex_cancel_dht_get, NULL);
-  GNUNET_CONTAINER_multihashmap_iterate(h->dht_get_results,
-                                        &regex_free_result, NULL);
-  GNUNET_CONTAINER_multihashmap_destroy(h->dht_get_results);
-  GNUNET_CONTAINER_multihashmap_destroy(h->dht_get_handles);
+  GNUNET_free (h->description);
+  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_handles,
+                                         &regex_cancel_dht_get, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_results,
+                                         &regex_free_result, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_results);
+  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_handles);
   if (0 < h->n_contexts)
-    {
-      for (i = 0; i < h->n_contexts; i++)
-        GNUNET_free(h->contexts[i]);
-      GNUNET_free(h->contexts);
-    }
-  GNUNET_free(h);
+  {
+    for (i = 0; i < h->n_contexts; i++)
+      GNUNET_free (h->contexts[i]);
+    GNUNET_free (h->contexts);
+  }
+  GNUNET_free (h);
 }