1 files changed, 667 insertions, 657 deletions

diff --git a/src/regex/gnunet-regex-profiler.c b/src/regex/gnunet-regex-profiler.c
index 4262107d7..16b7a7f0e 100644
--- a/src/regex/gnunet-regex-profiler.c
+++ b/src/regex/gnunet-regex-profiler.c
@@ -37,12 +37,13 @@
 #include "gnunet_testbed_service.h"
 
 #define FIND_TIMEOUT \
-  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90)
 
 /**
  * DLL of operations
  */
-struct DLLOperation {
+struct DLLOperation
+{
   /**
    * The testbed operation handle
    */
@@ -68,7 +69,8 @@ struct DLLOperation {
 /**
  * Available states during profiling
  */
-enum State {
+enum State
+{
   /**
    * Initial state
    */
@@ -110,7 +112,8 @@ enum State {
 /**
  * Peer handles.
  */
-struct RegexPeer {
+struct RegexPeer
+{
   /**
    * Peer id.
    */
@@ -167,7 +170,7 @@ struct RegexPeer {
   /**
    * Operation timeout
    */
-  struct GNUNET_SCHEDULER_Task * timeout;
+  struct GNUNET_SCHEDULER_Task *timeout;
 
   /**
    * Deamon start
@@ -208,12 +211,12 @@ static struct GNUNET_CONFIGURATION_Handle *cfg;
 /**
  * Abort task identifier
  */
-static struct GNUNET_SCHEDULER_Task * abort_task;
+static struct GNUNET_SCHEDULER_Task *abort_task;
 
 /**
  * Host registration task identifier
  */
-static struct GNUNET_SCHEDULER_Task * register_hosts_task;
+static struct GNUNET_SCHEDULER_Task *register_hosts_task;
 
 /**
  * Global event mask for all testbed events
@@ -248,7 +251,7 @@ enum State state;
 /**
  * Folder where policy files are stored.
  */
-static char * policy_dir;
+static char *policy_dir;
 
 /**
  * File with hostnames where to execute the test.
@@ -288,7 +291,7 @@ static unsigned int next_search;
 /**
  * Search timeout task identifier.
  */
-static struct GNUNET_SCHEDULER_Task * search_timeout_task;
+static struct GNUNET_SCHEDULER_Task *search_timeout_task;
 
 /**
  * Search timeout in seconds.
@@ -309,7 +312,7 @@ static char *data_filename;
  * Prefix used for regex announcing. We need to prefix the search
  * strings with it, in order to find something.
  */
-static char * regex_prefix;
+static char *regex_prefix;
 
 /**
  * What's the maximum regex reannounce period.
@@ -330,8 +333,8 @@ static struct GNUNET_TIME_Relative reannounce_period_max;
  * @param emsg error message.
  */
 static void
-dht_connect_cb(void *cls, struct GNUNET_TESTBED_Operation *op,
-               void *ca_result, const char *emsg);
+dht_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
+                void *ca_result, const char *emsg);
 
 /**
  * DHT connect adapter.
@@ -342,7 +345,7 @@ dht_connect_cb(void *cls, struct GNUNET_TESTBED_Operation *op,
  * @return
  */
 static void *
-dht_ca(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg);
+dht_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 
 /**
@@ -353,7 +356,7 @@ dht_ca(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg);
  * @param op_result service handle returned from the connect adapter
  */
 static void
-dht_da(void *cls, void *op_result);
+dht_da (void *cls, void *op_result);
 
 
 /**
@@ -366,10 +369,10 @@ dht_da(void *cls, void *op_result);
  * @param emsg error message on failure
  */
 static void
-stats_connect_cb(void *cls,
-                 struct GNUNET_TESTBED_Operation *op,
-                 void *ca_result,
-                 const char *emsg);
+stats_connect_cb (void *cls,
+                  struct GNUNET_TESTBED_Operation *op,
+                  void *ca_result,
+                  const char *emsg);
 
 
 /**
@@ -378,7 +381,7 @@ stats_connect_cb(void *cls,
  * @param cls Index of the next peer in the peers array.
  */
 static void
-announce_next_regex(void *cls);
+announce_next_regex (void *cls);
 
 
 /******************************************************************************/
@@ -392,7 +395,7 @@ announce_next_regex(void *cls);
  * @param cls NULL
  */
 static void
-do_shutdown(void *cls)
+do_shutdown (void *cls)
 {
   struct RegexPeer *peer;
   unsigned int peer_cnt;
@@ -401,75 +404,75 @@ do_shutdown(void *cls)
   size_t size;
 
   if (NULL != abort_task)
-    {
-      GNUNET_SCHEDULER_cancel(abort_task);
-      abort_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (abort_task);
+    abort_task = NULL;
+  }
   if (NULL != register_hosts_task)
-    {
-      GNUNET_SCHEDULER_cancel(register_hosts_task);
-      register_hosts_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (register_hosts_task);
+    register_hosts_task = NULL;
+  }
   for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
+  {
+    peer = &peers[peer_cnt];
+
+    if ((GNUNET_YES != peer->search_str_matched) &&(NULL != data_file) )
     {
-      peer = &peers[peer_cnt];
-
-      if (GNUNET_YES != peer->search_str_matched && NULL != data_file)
-        {
-          prof_time = GNUNET_TIME_absolute_get_duration(peer->prof_start_time);
-          size =
-            GNUNET_snprintf(output_buffer,
-                            sizeof(output_buffer),
-                            "%p Search string not found: %s (%d)\n"
-                            "%p On peer: %u (%p)\n"
-                            "%p After: %s\n",
-                            peer, peer->search_str, peer->search_str_matched,
-                            peer, peer->id, peer,
-                            peer,
-                            GNUNET_STRINGS_relative_time_to_string(prof_time,
-                                                                   GNUNET_NO));
-          if (size != GNUNET_DISK_file_write(data_file, output_buffer, size))
-            GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
-        }
-
-      if (NULL != peers[peer_cnt].op_handle)
-        GNUNET_TESTBED_operation_done(peers[peer_cnt].op_handle);
+      prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
+      size =
+        GNUNET_snprintf (output_buffer,
+                         sizeof(output_buffer),
+                         "%p Search string not found: %s (%d)\n"
+                         "%p On peer: %u (%p)\n"
+                         "%p After: %s\n",
+                         peer, peer->search_str, peer->search_str_matched,
+                         peer, peer->id, peer,
+                         peer,
+                         GNUNET_STRINGS_relative_time_to_string (prof_time,
+                                                                 GNUNET_NO));
+      if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
     }
 
+    if (NULL != peers[peer_cnt].op_handle)
+      GNUNET_TESTBED_operation_done (peers[peer_cnt].op_handle);
+  }
+
   if (NULL != data_file)
-    {
-      GNUNET_DISK_file_close(data_file);
-      data_file = NULL;
-    }
+  {
+    GNUNET_DISK_file_close (data_file);
+    data_file = NULL;
+  }
   for (search_str_cnt = 0;
        search_str_cnt < num_peers && NULL != search_strings;
        search_str_cnt++)
-    {
-      GNUNET_free_non_null(search_strings[search_str_cnt]);
-    }
-  GNUNET_free_non_null(search_strings);
+  {
+    GNUNET_free_non_null (search_strings[search_str_cnt]);
+  }
+  GNUNET_free_non_null (search_strings);
   search_strings = NULL;
 
   if (NULL != reg_handle)
-    {
-      GNUNET_TESTBED_cancel_registration(reg_handle);
-      reg_handle = NULL;
-    }
+  {
+    GNUNET_TESTBED_cancel_registration (reg_handle);
+    reg_handle = NULL;
+  }
   if (NULL != mc)
-    {
-      GNUNET_TESTBED_controller_disconnect(mc);
-      mc = NULL;
-    }
+  {
+    GNUNET_TESTBED_controller_disconnect (mc);
+    mc = NULL;
+  }
   if (NULL != mc_proc)
-    {
-      GNUNET_TESTBED_controller_stop(mc_proc);
-      mc_proc = NULL;
-    }
+  {
+    GNUNET_TESTBED_controller_stop (mc_proc);
+    mc_proc = NULL;
+  }
   if (NULL != cfg)
-    {
-      GNUNET_CONFIGURATION_destroy(cfg);
-      cfg = NULL;
-    }
+  {
+    GNUNET_CONFIGURATION_destroy (cfg);
+    cfg = NULL;
+  }
 }
 
 
@@ -479,15 +482,15 @@ do_shutdown(void *cls)
  * @param cls NULL
  */
 static void
-do_abort(void *cls)
+do_abort (void *cls)
 {
-  unsigned long i = (unsigned long)cls;
+  unsigned long i = (unsigned long) cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             "Aborting from line %lu...\n", i);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Aborting from line %lu...\n", i);
   abort_task = NULL;
   result = GNUNET_SYSERR;
-  GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
+  GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
 }
 
 
@@ -506,10 +509,10 @@ do_abort(void *cls)
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-stats_ca(void *cls,
-         const struct GNUNET_CONFIGURATION_Handle *cfg)
+stats_ca (void *cls,
+          const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  return GNUNET_STATISTICS_create("<driver>", cfg);
+  return GNUNET_STATISTICS_create ("<driver>", cfg);
 }
 
 
@@ -521,13 +524,13 @@ stats_ca(void *cls,
  * @param op_result service handle returned from the connect adapter
  */
 static void
-stats_da(void *cls, void *op_result)
+stats_da (void *cls, void *op_result)
 {
   struct RegexPeer *peer = cls;
 
-  GNUNET_assert(op_result == peer->stats_handle);
+  GNUNET_assert (op_result == peer->stats_handle);
 
-  GNUNET_STATISTICS_destroy(peer->stats_handle, GNUNET_NO);
+  GNUNET_STATISTICS_destroy (peer->stats_handle, GNUNET_NO);
   peer->stats_handle = NULL;
 }
 
@@ -543,34 +546,34 @@ stats_da(void *cls, void *op_result)
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-stats_iterator(void *cls,
-               const char *subsystem,
-               const char *name,
-               uint64_t value, int is_persistent)
+stats_iterator (void *cls,
+                const char *subsystem,
+                const char *name,
+                uint64_t value, int is_persistent)
 {
   struct RegexPeer *peer = cls;
   char output_buffer[512];
   size_t size;
 
   if (NULL == data_file)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "%p -> %s [%s]: %llu\n",
-                 peer,
-                 subsystem,
-                 name,
-                 (unsigned long long)value);
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "%p -> %s [%s]: %llu\n",
+                peer,
+                subsystem,
+                name,
+                (unsigned long long) value);
+    return GNUNET_OK;
+  }
   size =
-    GNUNET_snprintf(output_buffer,
-                    sizeof(output_buffer),
-                    "%p [%s] %llu %s\n",
-                    peer,
-                    subsystem, value, name);
-  if (size != GNUNET_DISK_file_write(data_file, output_buffer, size))
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-               "Unable to write to file!\n");
+    GNUNET_snprintf (output_buffer,
+                     sizeof(output_buffer),
+                     "%p [%s] %llu %s\n",
+                     peer,
+                     subsystem, value, name);
+  if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unable to write to file!\n");
 
   return GNUNET_OK;
 }
@@ -585,48 +588,48 @@ stats_iterator(void *cls,
  *        successfully obtained, GNUNET_SYSERR if not.
  */
 static void
-stats_cb(void *cls,
-         int success)
+stats_cb (void *cls,
+          int success)
 {
   static unsigned int peer_cnt;
   struct RegexPeer *peer = cls;
 
   if (GNUNET_OK != success)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Getting statistics for peer %u failed!\n",
-                 peer->id);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Getting statistics for peer %u failed!\n",
+                peer->id);
+    return;
+  }
 
-  GNUNET_assert(NULL != peer->op_handle);
+  GNUNET_assert (NULL != peer->op_handle);
 
-  GNUNET_TESTBED_operation_done(peer->op_handle);
+  GNUNET_TESTBED_operation_done (peer->op_handle);
   peer->op_handle = NULL;
 
   peer_cnt++;
   peer = &peers[peer_cnt];
 
-  fprintf(stderr, "s");
+  fprintf (stderr, "s");
   if (peer_cnt == num_peers)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "\nCollecting stats finished. Shutting down.\n");
-      GNUNET_SCHEDULER_shutdown();
-      result = GNUNET_OK;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "\nCollecting stats finished. Shutting down.\n");
+    GNUNET_SCHEDULER_shutdown ();
+    result = GNUNET_OK;
+  }
   else
-    {
-      peer->op_handle =
-        GNUNET_TESTBED_service_connect(NULL,
-                                       peer->peer_handle,
-                                       "statistics",
-                                       &stats_connect_cb,
-                                       peer,
-                                       &stats_ca,
-                                       &stats_da,
-                                       peer);
-    }
+  {
+    peer->op_handle =
+      GNUNET_TESTBED_service_connect (NULL,
+                                      peer->peer_handle,
+                                      "statistics",
+                                      &stats_connect_cb,
+                                      peer,
+                                      &stats_ca,
+                                      &stats_da,
+                                      peer);
+  }
 }
 
 
@@ -640,32 +643,32 @@ stats_cb(void *cls,
  * @param emsg error message on failure
  */
 static void
-stats_connect_cb(void *cls,
-                 struct GNUNET_TESTBED_Operation *op,
-                 void *ca_result,
-                 const char *emsg)
+stats_connect_cb (void *cls,
+                  struct GNUNET_TESTBED_Operation *op,
+                  void *ca_result,
+                  const char *emsg)
 {
   struct RegexPeer *peer = cls;
 
-  if (NULL == ca_result || NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Failed to connect to statistics service on peer %u: %s\n",
-                 peer->id, emsg);
+  if ((NULL == ca_result)||(NULL != emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to connect to statistics service on peer %u: %s\n",
+                peer->id, emsg);
 
-      peer->stats_handle = NULL;
-      return;
-    }
+    peer->stats_handle = NULL;
+    return;
+  }
 
   peer->stats_handle = ca_result;
 
-  if (NULL == GNUNET_STATISTICS_get(peer->stats_handle, NULL, NULL,
-                                    &stats_cb,
-                                    &stats_iterator, peer))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Could not get statistics of peer %u!\n", peer->id);
-    }
+  if (NULL == GNUNET_STATISTICS_get (peer->stats_handle, NULL, NULL,
+                                     &stats_cb,
+                                     &stats_iterator, peer))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not get statistics of peer %u!\n", peer->id);
+  }
 }
 
 
@@ -676,21 +679,21 @@ stats_connect_cb(void *cls,
  * @param cls NULL
  */
 static void
-do_collect_stats(void *cls)
+do_collect_stats (void *cls)
 {
   struct RegexPeer *peer = &peers[0];
 
-  GNUNET_assert(NULL != peer->peer_handle);
+  GNUNET_assert (NULL != peer->peer_handle);
 
   peer->op_handle =
-    GNUNET_TESTBED_service_connect(NULL,
-                                   peer->peer_handle,
-                                   "statistics",
-                                   &stats_connect_cb,
-                                   peer,
-                                   &stats_ca,
-                                   &stats_da,
-                                   peer);
+    GNUNET_TESTBED_service_connect (NULL,
+                                    peer->peer_handle,
+                                    "statistics",
+                                    &stats_connect_cb,
+                                    peer,
+                                    &stats_ca,
+                                    &stats_da,
+                                    peer);
 }
 
 
@@ -705,7 +708,7 @@ do_collect_stats(void *cls)
  * @param cls Index of the next peer in the peers array.
  */
 static void
-find_string(void *cls);
+find_string (void *cls);
 
 
 /**
@@ -720,94 +723,94 @@ find_string(void *cls);
  * @param put_path_length Length of the put_path.
  */
 static void
-regex_found_handler(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)
+regex_found_handler (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)
 {
   struct RegexPeer *peer = cls;
   char output_buffer[512];
   size_t size;
 
   if (GNUNET_YES == peer->search_str_matched)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "String %s on peer %u already matched!\n",
-                 peer->search_str, peer->id);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "String %s on peer %u already matched!\n",
+                peer->search_str, peer->id);
+    return;
+  }
 
   strings_found++;
   parallel_searches--;
 
   if (NULL != peer->timeout)
-    {
-      GNUNET_SCHEDULER_cancel(peer->timeout);
-      peer->timeout = NULL;
-      if (GNUNET_NO == in_shutdown)
-        GNUNET_SCHEDULER_add_now(&announce_next_regex, NULL);
-    }
+  {
+    GNUNET_SCHEDULER_cancel (peer->timeout);
+    peer->timeout = NULL;
+    if (GNUNET_NO == in_shutdown)
+      GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
+  }
 
   if (NULL == id)
-    {
-      // FIXME not possible right now
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "String matching timed out for string %s on peer %u (%i/%i)\n",
-                 peer->search_str, peer->id, strings_found, num_peers);
-      peer->search_str_matched = GNUNET_SYSERR;
-    }
+  {
+    // FIXME not possible right now
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "String matching timed out for string %s on peer %u (%i/%i)\n",
+                peer->search_str, peer->id, strings_found, num_peers);
+    peer->search_str_matched = GNUNET_SYSERR;
+  }
   else
+  {
+    prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "String %s found on peer %u after %s (%i/%i) (%u||)\n",
+                peer->search_str, peer->id,
+                GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO),
+                strings_found, num_peers, parallel_searches);
+
+    peer->search_str_matched = GNUNET_YES;
+
+    if (NULL != data_file)
     {
-      prof_time = GNUNET_TIME_absolute_get_duration(peer->prof_start_time);
-
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "String %s found on peer %u after %s (%i/%i) (%u||)\n",
-                 peer->search_str, peer->id,
-                 GNUNET_STRINGS_relative_time_to_string(prof_time, GNUNET_NO),
-                 strings_found, num_peers, parallel_searches);
-
-      peer->search_str_matched = GNUNET_YES;
-
-      if (NULL != data_file)
-        {
-          size =
-            GNUNET_snprintf(output_buffer,
-                            sizeof(output_buffer),
-                            "%p Peer: %u\n"
-                            "%p Search string: %s\n"
-                            "%p Search duration: %s\n\n",
-                            peer, peer->id,
-                            peer, peer->search_str,
-                            peer,
-                            GNUNET_STRINGS_relative_time_to_string(prof_time,
-                                                                   GNUNET_NO));
-
-          if (size != GNUNET_DISK_file_write(data_file, output_buffer, size))
-            GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
-        }
+      size =
+        GNUNET_snprintf (output_buffer,
+                         sizeof(output_buffer),
+                         "%p Peer: %u\n"
+                         "%p Search string: %s\n"
+                         "%p Search duration: %s\n\n",
+                         peer, peer->id,
+                         peer, peer->search_str,
+                         peer,
+                         GNUNET_STRINGS_relative_time_to_string (prof_time,
+                                                                 GNUNET_NO));
+
+      if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
     }
+  }
 
-  GNUNET_TESTBED_operation_done(peer->op_handle);
+  GNUNET_TESTBED_operation_done (peer->op_handle);
   peer->op_handle = NULL;
 
   if (strings_found == num_peers)
-    {
-      prof_time = GNUNET_TIME_absolute_get_duration(prof_start_time);
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "All strings successfully matched in %s\n",
-                 GNUNET_STRINGS_relative_time_to_string(prof_time, GNUNET_NO));
-
-      if (NULL != search_timeout_task)
-        {
-          GNUNET_SCHEDULER_cancel(search_timeout_task);
-          search_timeout_task = NULL;
-        }
+  {
+    prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "All strings successfully matched in %s\n",
+                GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
 
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Collecting stats.\n");
-      GNUNET_SCHEDULER_add_now(&do_collect_stats, NULL);
+    if (NULL != search_timeout_task)
+    {
+      GNUNET_SCHEDULER_cancel (search_timeout_task);
+      search_timeout_task = NULL;
     }
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Collecting stats.\n");
+    GNUNET_SCHEDULER_add_now (&do_collect_stats, NULL);
+  }
 }
 
 
@@ -818,33 +821,33 @@ regex_found_handler(void *cls,
  * @param cls NULL
  */
 static void
-search_timed_out(void *cls)
+search_timed_out (void *cls)
 {
   unsigned int i;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Finding matches to all strings did not succeed after %s.\n",
-             GNUNET_STRINGS_relative_time_to_string(search_timeout_time,
-                                                    GNUNET_NO));
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Found %i of %i strings\n", strings_found, num_peers);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Finding matches to all strings did not succeed after %s.\n",
+              GNUNET_STRINGS_relative_time_to_string (search_timeout_time,
+                                                      GNUNET_NO));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Found %i of %i strings\n", strings_found, num_peers);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Search timed out after %s."
-             "Collecting stats and shutting down.\n",
-             GNUNET_STRINGS_relative_time_to_string(search_timeout_time,
-                                                    GNUNET_NO));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Search timed out after %s."
+              "Collecting stats and shutting down.\n",
+              GNUNET_STRINGS_relative_time_to_string (search_timeout_time,
+                                                      GNUNET_NO));
 
   in_shutdown = GNUNET_YES;
   for (i = 0; i < num_peers; i++)
+  {
+    if (NULL != peers[i].op_handle)
     {
-      if (NULL != peers[i].op_handle)
-        {
-          GNUNET_TESTBED_operation_done(peers[i].op_handle);
-          peers[i].op_handle = NULL;
-        }
+      GNUNET_TESTBED_operation_done (peers[i].op_handle);
+      peers[i].op_handle = NULL;
     }
-  GNUNET_SCHEDULER_add_now(&do_collect_stats, NULL);
+  }
+  GNUNET_SCHEDULER_add_now (&do_collect_stats, NULL);
 }
 
 
@@ -855,17 +858,17 @@ search_timed_out(void *cls)
  * @param cls Index of the next peer in the peers array.
  */
 static void
-find_timed_out(void *cls)
+find_timed_out (void *cls)
 {
   struct RegexPeer *p = cls;
 
   p->timeout = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             "Searching for string \"%s\" on peer %d timed out.\n",
-             p->search_str,
-             p->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Searching for string \"%s\" on peer %d timed out.\n",
+              p->search_str,
+              p->id);
   if (GNUNET_NO == in_shutdown)
-    GNUNET_SCHEDULER_add_now(&announce_next_regex, NULL);
+    GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
 }
 
 
@@ -875,34 +878,34 @@ find_timed_out(void *cls)
  * @param cls Index of the next peer in the peers array.
  */
 static void
-find_string(void *cls)
+find_string (void *cls)
 {
-  unsigned int search_peer = (unsigned int)(long)cls;
+  unsigned int search_peer = (unsigned int) (long) cls;
 
   if ((search_peer >= num_peers) ||
       (GNUNET_YES == in_shutdown))
     return;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Searching for string \"%s\" on peer %d (%u||)\n",
-             peers[search_peer].search_str,
-             search_peer,
-             parallel_searches);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Searching for string \"%s\" on peer %d (%u||)\n",
+              peers[search_peer].search_str,
+              search_peer,
+              parallel_searches);
 
   peers[search_peer].op_handle =
-    GNUNET_TESTBED_service_connect(NULL,
-                                   peers[search_peer].peer_handle,
-                                   "dht",
-                                   &dht_connect_cb,
-                                   &peers[search_peer],
-                                   &dht_ca,
-                                   &dht_da,
-                                   &peers[search_peer]);
-  GNUNET_assert(NULL != peers[search_peer].op_handle);
+    GNUNET_TESTBED_service_connect (NULL,
+                                    peers[search_peer].peer_handle,
+                                    "dht",
+                                    &dht_connect_cb,
+                                    &peers[search_peer],
+                                    &dht_ca,
+                                    &dht_da,
+                                    &peers[search_peer]);
+  GNUNET_assert (NULL != peers[search_peer].op_handle);
   peers[search_peer].timeout
-    = GNUNET_SCHEDULER_add_delayed(FIND_TIMEOUT,
-                                   &find_timed_out,
-                                   &peers[search_peer]);
+    = GNUNET_SCHEDULER_add_delayed (FIND_TIMEOUT,
+                                    &find_timed_out,
+                                    &peers[search_peer]);
 }
 
 
@@ -914,44 +917,44 @@ find_string(void *cls)
  * @param emsg NULL on success; otherwise an error description
  */
 static void
-daemon_started(void *cls,
-               struct GNUNET_TESTBED_Operation *op,
-               const char *emsg)
+daemon_started (void *cls,
+                struct GNUNET_TESTBED_Operation *op,
+                const char *emsg)
 {
-  struct RegexPeer *peer = (struct RegexPeer *)cls;
+  struct RegexPeer *peer = (struct RegexPeer *) cls;
   unsigned long search_peer;
   unsigned int i;
 
-  GNUNET_TESTBED_operation_done(peer->daemon_op);
+  GNUNET_TESTBED_operation_done (peer->daemon_op);
   peer->daemon_op = NULL;
   if (NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Failed to start/stop daemon at peer %u: %s\n", peer->id, emsg);
-      GNUNET_assert(0);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to start/stop daemon at peer %u: %s\n", peer->id, emsg);
+    GNUNET_assert (0);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Deamon %u started successfully\n", peer->id);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Deamon %u started successfully\n", peer->id);
+  }
 
   /* Find a peer to look for a string matching the regex announced */
-  search_peer = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                         num_peers);
+  search_peer = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                          num_peers);
   for (i = 0; peers[search_peer].search_str != NULL; i++)
-    {
-      search_peer = (search_peer + 1) % num_peers;
-      if (i > num_peers)
-        GNUNET_assert(0); /* we ran out of peers, must be a bug */
-    }
+  {
+    search_peer = (search_peer + 1) % num_peers;
+    if (i > num_peers)
+      GNUNET_assert (0);  /* we ran out of peers, must be a bug */
+  }
   peers[search_peer].search_str = search_strings[peer->id];
   peers[search_peer].search_str_matched = GNUNET_NO;
-  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_saturating_multiply(
-                                 reannounce_period_max,
-                                 2),
-                               &find_string,
-                               (void *)search_peer);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_saturating_multiply (
+                                  reannounce_period_max,
+                                  2),
+                                &find_string,
+                                (void *) search_peer);
 }
 
 
@@ -963,21 +966,21 @@ daemon_started(void *cls,
  * @param tc the task context
  */
 static void
-do_announce(void *cls)
+do_announce (void *cls)
 {
   unsigned int i;
 
   if (GNUNET_YES == in_shutdown)
     return;
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Starting announce.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Starting announce.\n");
   for (i = 0; i < init_parallel_searches; i++)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "  scheduling announce %u\n",
-                 i);
-      (void)GNUNET_SCHEDULER_add_now(&announce_next_regex, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "  scheduling announce %u\n",
+                i);
+    (void) GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
+  }
 }
 
 
@@ -987,36 +990,36 @@ do_announce(void *cls)
  * @param cls Closure (unused).
  */
 static void
-announce_next_regex(void *cls)
+announce_next_regex (void *cls)
 {
   struct RegexPeer *peer;
 
   if (GNUNET_YES == in_shutdown)
     return;
   if (next_search >= num_peers)
+  {
+    if (strings_found != num_peers)
     {
-      if (strings_found != num_peers)
-        {
-          struct GNUNET_TIME_Relative new_delay;
-          if (NULL != search_timeout_task)
-            GNUNET_SCHEDULER_cancel(search_timeout_task);
-          new_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15);
-          search_timeout_task = GNUNET_SCHEDULER_add_delayed(new_delay,
-                                                             &search_timed_out,
-                                                             NULL);
-        }
-      return;
+      struct GNUNET_TIME_Relative new_delay;
+      if (NULL != search_timeout_task)
+        GNUNET_SCHEDULER_cancel (search_timeout_task);
+      new_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15);
+      search_timeout_task = GNUNET_SCHEDULER_add_delayed (new_delay,
+                                                          &search_timed_out,
+                                                          NULL);
     }
+    return;
+  }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Starting daemon %u\n", next_search);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting daemon %u\n", next_search);
   peer = &peers[next_search];
   peer->daemon_op =
-    GNUNET_TESTBED_peer_manage_service(NULL,
-                                       peer->peer_handle,
-                                       "regexprofiler",
-                                       &daemon_started,
-                                       peer,
-                                       1);
+    GNUNET_TESTBED_peer_manage_service (NULL,
+                                        peer->peer_handle,
+                                        "regexprofiler",
+                                        &daemon_started,
+                                        peer,
+                                        1);
   next_search++;
   parallel_searches++;
 }
@@ -1033,29 +1036,29 @@ announce_next_regex(void *cls)
  * @param emsg error message.
  */
 static void
-dht_connect_cb(void *cls,
-               struct GNUNET_TESTBED_Operation *op,
-               void *ca_result,
-               const char *emsg)
+dht_connect_cb (void *cls,
+                struct GNUNET_TESTBED_Operation *op,
+                void *ca_result,
+                const char *emsg)
 {
-  struct RegexPeer *peer = (struct RegexPeer *)cls;
+  struct RegexPeer *peer = (struct RegexPeer *) cls;
 
-  if (NULL != emsg || NULL == op || NULL == ca_result)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "DHT connect failed: %s\n", emsg);
-      GNUNET_assert(0);
-    }
+  if ((NULL != emsg)||(NULL == op)||(NULL == ca_result))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "DHT connect failed: %s\n", emsg);
+    GNUNET_assert (0);
+  }
 
-  GNUNET_assert(NULL != peer->dht_handle);
-  GNUNET_assert(peer->op_handle == op);
-  GNUNET_assert(peer->dht_handle == ca_result);
+  GNUNET_assert (NULL != peer->dht_handle);
+  GNUNET_assert (peer->op_handle == op);
+  GNUNET_assert (peer->dht_handle == ca_result);
 
   peer->search_str_matched = GNUNET_NO;
-  peer->search_handle = REGEX_INTERNAL_search(peer->dht_handle,
-                                              peer->search_str,
-                                              &regex_found_handler, peer,
-                                              NULL);
-  peer->prof_start_time = GNUNET_TIME_absolute_get();
+  peer->search_handle = REGEX_INTERNAL_search (peer->dht_handle,
+                                               peer->search_str,
+                                               &regex_found_handler, peer,
+                                               NULL);
+  peer->prof_start_time = GNUNET_TIME_absolute_get ();
 }
 
 
@@ -1068,11 +1071,11 @@ dht_connect_cb(void *cls,
  * @return
  */
 static void *
-dht_ca(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+dht_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct RegexPeer *peer = cls;
 
-  peer->dht_handle = GNUNET_DHT_connect(cfg, 32);
+  peer->dht_handle = GNUNET_DHT_connect (cfg, 32);
 
   return peer->dht_handle;
 }
@@ -1085,23 +1088,23 @@ dht_ca(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param op_result Service handle returned from the connect adapter.
  */
 static void
-dht_da(void *cls, void *op_result)
+dht_da (void *cls, void *op_result)
 {
-  struct RegexPeer *peer = (struct RegexPeer *)cls;
+  struct RegexPeer *peer = (struct RegexPeer *) cls;
 
-  GNUNET_assert(peer->dht_handle == op_result);
+  GNUNET_assert (peer->dht_handle == op_result);
 
   if (NULL != peer->search_handle)
-    {
-      REGEX_INTERNAL_search_cancel(peer->search_handle);
-      peer->search_handle = NULL;
-    }
+  {
+    REGEX_INTERNAL_search_cancel (peer->search_handle);
+    peer->search_handle = NULL;
+  }
 
   if (NULL != peer->dht_handle)
-    {
-      GNUNET_DHT_disconnect(peer->dht_handle);
-      peer->dht_handle = NULL;
-    }
+  {
+    GNUNET_DHT_disconnect (peer->dht_handle);
+    peer->dht_handle = NULL;
+  }
 }
 
 
@@ -1119,51 +1122,52 @@ dht_da(void *cls, void *op_result)
  *          failed
  */
 static void
-test_master(void *cls,
-            struct GNUNET_TESTBED_RunHandle *h,
-            unsigned int num_peers_,
-            struct GNUNET_TESTBED_Peer **testbed_peers,
-            unsigned int links_succeeded,
-            unsigned int links_failed)
+test_master (void *cls,
+             struct GNUNET_TESTBED_RunHandle *h,
+             unsigned int num_peers_,
+             struct GNUNET_TESTBED_Peer **testbed_peers,
+             unsigned int links_succeeded,
+             unsigned int links_failed)
 {
   unsigned int i;
 
-  GNUNET_assert(num_peers_ == num_peers);
+  GNUNET_assert (num_peers_ == num_peers);
 
-  prof_time = GNUNET_TIME_absolute_get_duration(prof_start_time);
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Testbed started in %s\n",
-             GNUNET_STRINGS_relative_time_to_string(prof_time, GNUNET_NO));
+  prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Testbed started in %s\n",
+              GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
 
   if (NULL != abort_task)
-    {
-      GNUNET_SCHEDULER_cancel(abort_task);
-      abort_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (abort_task);
+    abort_task = NULL;
+  }
 
   for (i = 0; i < num_peers; i++)
-    {
-      peers[i].peer_handle = testbed_peers[i];
-    }
+  {
+    peers[i].peer_handle = testbed_peers[i];
+  }
   if (GNUNET_NO ==
-      GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT", "DISABLE_TRY_CONNECT"))
-    {
-      struct GNUNET_TIME_Relative settle_time;
-
-      settle_time =
-        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,
-                                      10 * num_peers);
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Waiting for DHT for %s to settle new connections.\n\n",
-                 GNUNET_STRINGS_relative_time_to_string(settle_time, GNUNET_NO));
-      GNUNET_SCHEDULER_add_delayed(settle_time, &do_announce, NULL);
-    }
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "DHT", "DISABLE_TRY_CONNECT"))
+  {
+    struct GNUNET_TIME_Relative settle_time;
+
+    settle_time =
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+                                     10 * num_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Waiting for DHT for %s to settle new connections.\n\n",
+                GNUNET_STRINGS_relative_time_to_string (settle_time,
+                                                        GNUNET_NO));
+    GNUNET_SCHEDULER_add_delayed (settle_time, &do_announce, NULL);
+  }
   else
-    {
-      GNUNET_SCHEDULER_add_now(&do_announce, NULL);
-    }
+  {
+    GNUNET_SCHEDULER_add_now (&do_announce, NULL);
+  }
   search_timeout_task =
-    GNUNET_SCHEDULER_add_delayed(search_timeout_time, &search_timed_out, NULL);
+    GNUNET_SCHEDULER_add_delayed (search_timeout_time, &search_timed_out, NULL);
 }
 
 /**
@@ -1173,23 +1177,23 @@ test_master(void *cls,
  * @param event information on what is happening
  */
 static void
-master_controller_cb(void *cls,
-                     const struct GNUNET_TESTBED_EventInformation *event)
+master_controller_cb (void *cls,
+                      const struct GNUNET_TESTBED_EventInformation *event)
 {
   switch (event->type)
-    {
-    case GNUNET_TESTBED_ET_CONNECT:
-      printf(".");
-      break;
-
-    case GNUNET_TESTBED_ET_PEER_START:
-      printf("#");
-      break;
-
-    default:
-      break;
-    }
-  fflush(stdout);
+  {
+  case GNUNET_TESTBED_ET_CONNECT:
+    printf (".");
+    break;
+
+  case GNUNET_TESTBED_ET_PEER_START:
+    printf ("#");
+    break;
+
+  default:
+    break;
+  }
+  fflush (stdout);
 }
 
 
@@ -1208,9 +1212,9 @@ master_controller_cb(void *cls,
  *         #GNUNET_SYSERR otherwise.
  */
 static int
-count_and_separate_strings(char *data,
-                           uint64_t data_size,
-                           unsigned int str_max)
+count_and_separate_strings (char *data,
+                            uint64_t data_size,
+                            unsigned int str_max)
 {
   char *buf;            // Keep track of last string to skip blank lines
   unsigned int offset;
@@ -1220,19 +1224,19 @@ count_and_separate_strings(char *data,
   offset = 0;
   str_cnt = 0;
   while ((offset < (data_size - 1)) && (str_cnt < str_max))
+  {
+    offset++;
+    if (((data[offset] == '\n')) &&
+        (buf != &data[offset]))
     {
-      offset++;
-      if (((data[offset] == '\n')) &&
-          (buf != &data[offset]))
-        {
-          data[offset] = '\0';
-          str_cnt++;
-          buf = &data[offset + 1];
-        }
-      else if ((data[offset] == '\n') ||
-               (data[offset] == '\0'))
-        buf = &data[offset + 1];
+      data[offset] = '\0';
+      str_cnt++;
+      buf = &data[offset + 1];
     }
+    else if ((data[offset] == '\n') ||
+             (data[offset] == '\0'))
+      buf = &data[offset + 1];
+  }
   return str_cnt;
 }
 
@@ -1251,37 +1255,37 @@ count_and_separate_strings(char *data,
  *         In case of error @a strings must not be freed.
  */
 static int
-create_string_array(char *data, uint64_t data_size,
-                    char ***strings, unsigned int str_cnt)
+create_string_array (char *data, uint64_t data_size,
+                     char ***strings, unsigned int str_cnt)
 {
   uint64_t offset;
   uint64_t len;
   unsigned int i;
 
-  *strings = GNUNET_malloc(sizeof(char *) * str_cnt);
+  *strings = GNUNET_malloc (sizeof(char *) * str_cnt);
   offset = 0;
   for (i = 0; i < str_cnt; i++)
+  {
+    len = strlen (&data[offset]);
+    if (offset + len >= data_size)
+    {
+      GNUNET_free (*strings);
+      *strings = NULL;
+      return GNUNET_SYSERR;
+    }
+    if (0 == len)   // empty line
     {
-      len = strlen(&data[offset]);
-      if (offset + len >= data_size)
-        {
-          GNUNET_free(*strings);
-          *strings = NULL;
-          return GNUNET_SYSERR;
-        }
-      if (0 == len) // empty line
-        {
-          offset++;
-          i--;
-          continue;
-        }
-
-      GNUNET_asprintf(&(*strings)[i],
-                      "%s%s",
-                      regex_prefix,
-                      &data[offset]);
-      offset += len + 1;
+      offset++;
+      i--;
+      continue;
     }
+
+    GNUNET_asprintf (&(*strings)[i],
+                     "%s%s",
+                     regex_prefix,
+                     &data[offset]);
+    offset += len + 1;
+  }
   return GNUNET_OK;
 }
 
@@ -1296,9 +1300,9 @@ create_string_array(char *data, uint64_t data_size,
  * @return number of strings found in the file. #GNUNET_SYSERR on error.
  */
 static int
-load_search_strings(const char *filename,
-                    char ***strings,
-                    unsigned int limit)
+load_search_strings (const char *filename,
+                     char ***strings,
+                     unsigned int limit)
 {
   char *data;
   uint64_t filesize;
@@ -1306,54 +1310,54 @@ load_search_strings(const char *filename,
 
   /* Sanity checks */
   if (NULL == filename)
-    {
-      return GNUNET_SYSERR;
-    }
-  if (GNUNET_YES != GNUNET_DISK_file_test(filename))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Could not find search strings file %s\n", filename);
-      return GNUNET_SYSERR;
-    }
+  {
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Could not find search strings file %s\n", filename);
+    return GNUNET_SYSERR;
+  }
   if (GNUNET_OK !=
-      GNUNET_DISK_file_size(filename,
-                            &filesize,
-                            GNUNET_YES,
-                            GNUNET_YES))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Search strings file %s cannot be read.\n",
-                 filename);
-      return GNUNET_SYSERR;
-    }
+      GNUNET_DISK_file_size (filename,
+                             &filesize,
+                             GNUNET_YES,
+                             GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Search strings file %s cannot be read.\n",
+                filename);
+    return GNUNET_SYSERR;
+  }
   if (0 == filesize)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Search strings file %s is empty.\n",
-                 filename);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Search strings file %s is empty.\n",
+                filename);
+    return GNUNET_SYSERR;
+  }
 
   /* Read data into memory */
-  data = GNUNET_malloc(filesize + 1);
-  if (filesize != GNUNET_DISK_fn_read(filename,
-                                      data,
-                                      filesize))
-    {
-      GNUNET_free(data);
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Could not read search strings file %s.\n",
-                 filename);
-      return GNUNET_SYSERR;
-    }
+  data = GNUNET_malloc (filesize + 1);
+  if (filesize != GNUNET_DISK_fn_read (filename,
+                                       data,
+                                       filesize))
+  {
+    GNUNET_free (data);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Could not read search strings file %s.\n",
+                filename);
+    return GNUNET_SYSERR;
+  }
 
   /* Process buffer and build array */
-  str_cnt = count_and_separate_strings(data, filesize, limit);
-  if (GNUNET_OK != create_string_array(data, filesize, strings, str_cnt))
-    {
-      str_cnt = GNUNET_SYSERR;
-    }
-  GNUNET_free(data);
+  str_cnt = count_and_separate_strings (data, filesize, limit);
+  if (GNUNET_OK != create_string_array (data, filesize, strings, str_cnt))
+  {
+    str_cnt = GNUNET_SYSERR;
+  }
+  GNUNET_free (data);
   return str_cnt;
 }
 
@@ -1367,10 +1371,10 @@ load_search_strings(const char *filename,
  * @param config configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *config)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *config)
 {
   unsigned int nsearchstrs;
   unsigned int i;
@@ -1380,161 +1384,163 @@ run(void *cls,
 
   /* Check config */
   if (NULL == config)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("No configuration file given. Exiting\n"));
-      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-      return;
-    }
-  cfg = GNUNET_CONFIGURATION_dup(config);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("No configuration file given. Exiting\n"));
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
+  cfg = GNUNET_CONFIGURATION_dup (config);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(cfg, "REGEXPROFILER",
-                                            "REGEX_PREFIX",
-                                            &regex_prefix))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
-                                "regexprofiler",
-                                "regex_prefix");
-      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_string (cfg, "REGEXPROFILER",
+                                             "REGEX_PREFIX",
+                                             &regex_prefix))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "regexprofiler",
+                               "regex_prefix");
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number(cfg, "REGEXPROFILER",
-                                            "PARALLEL_SEARCHES",
-                                            &init_parallel_searches))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Configuration option \"PARALLEL_SEARCHES\" missing."
-                 " Using default (%d)\n", 10);
-      init_parallel_searches = 10;
-    }
+      GNUNET_CONFIGURATION_get_value_number (cfg, "REGEXPROFILER",
+                                             "PARALLEL_SEARCHES",
+                                             &init_parallel_searches))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Configuration option \"PARALLEL_SEARCHES\" missing."
+                " Using default (%d)\n", 10);
+    init_parallel_searches = 10;
+  }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time(cfg, "REGEXPROFILER",
-                                          "REANNOUNCE_PERIOD_MAX",
-                                          &reannounce_period_max))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "reannounce_period_max not given. Using 10 minutes.\n");
-      reannounce_period_max =
-        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 10);
-    }
+      GNUNET_CONFIGURATION_get_value_time (cfg, "REGEXPROFILER",
+                                           "REANNOUNCE_PERIOD_MAX",
+                                           &reannounce_period_max))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "reannounce_period_max not given. Using 10 minutes.\n");
+    reannounce_period_max =
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 10);
+  }
 
   /* Check arguments */
   if (NULL == policy_dir)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("No policy directory specified on command line. Exiting.\n"));
-      return;
-    }
-  if (GNUNET_YES != GNUNET_DISK_directory_test(policy_dir, GNUNET_YES))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Specified policies directory does not exist. Exiting.\n"));
-      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-      return;
-    }
-  if (0 >= (int)(num_peers = GNUNET_DISK_directory_scan(policy_dir, NULL, NULL)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("No files found in `%s'\n"),
-                 policy_dir);
-      return;
-    }
-  GNUNET_CONFIGURATION_set_value_string(cfg, "REGEXPROFILER",
-                                        "POLICY_DIR", policy_dir);
-  if (GNUNET_YES != GNUNET_DISK_file_test(strings_file))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("No search strings file given. Exiting.\n"));
-      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-      return;
-    }
-  nsearchstrs = load_search_strings(strings_file,
-                                    &search_strings,
-                                    num_peers);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ (
+                  "No policy directory specified on command line. Exiting.\n"));
+    return;
+  }
+  if (GNUNET_YES != GNUNET_DISK_directory_test (policy_dir, GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Specified policies directory does not exist. Exiting.\n"));
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
+  if (0 >= (int) (num_peers = GNUNET_DISK_directory_scan (policy_dir, NULL,
+                                                          NULL)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("No files found in `%s'\n"),
+                policy_dir);
+    return;
+  }
+  GNUNET_CONFIGURATION_set_value_string (cfg, "REGEXPROFILER",
+                                         "POLICY_DIR", policy_dir);
+  if (GNUNET_YES != GNUNET_DISK_file_test (strings_file))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("No search strings file given. Exiting.\n"));
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
+  nsearchstrs = load_search_strings (strings_file,
+                                     &search_strings,
+                                     num_peers);
   if (num_peers != nsearchstrs)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Error loading search strings.\n");
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "File (%s) does not contain enough strings (%u/%u).\n",
-                 strings_file, nsearchstrs, num_peers);
-      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Error loading search strings.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "File (%s) does not contain enough strings (%u/%u).\n",
+                strings_file, nsearchstrs, num_peers);
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
   if ((0 == num_peers) || (NULL == search_strings))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Error loading search strings. Exiting.\n"));
-      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Error loading search strings. Exiting.\n"));
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
   for (i = 0; i < num_peers; i++)
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "search string: %s\n",
-               search_strings[i]);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "search string: %s\n",
+                search_strings[i]);
 
   /* Check logfile */
   if ((NULL != data_filename) &&
       (NULL == (data_file =
-                  GNUNET_DISK_file_open(data_filename,
-                                        GNUNET_DISK_OPEN_READWRITE |
-                                        GNUNET_DISK_OPEN_TRUNCATE |
-                                        GNUNET_DISK_OPEN_CREATE,
-                                        GNUNET_DISK_PERM_USER_READ |
-                                        GNUNET_DISK_PERM_USER_WRITE))))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
-                               "open",
-                               data_filename);
-      return;
-    }
+                  GNUNET_DISK_file_open (data_filename,
+                                         GNUNET_DISK_OPEN_READWRITE
+                                         | GNUNET_DISK_OPEN_TRUNCATE
+                                         | GNUNET_DISK_OPEN_CREATE,
+                                         GNUNET_DISK_PERM_USER_READ
+                                         | GNUNET_DISK_PERM_USER_WRITE))))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                              "open",
+                              data_filename);
+    return;
+  }
 
   /* Initialize peers */
-  peers = GNUNET_malloc(sizeof(struct RegexPeer) * num_peers);
+  peers = GNUNET_malloc (sizeof(struct RegexPeer) * num_peers);
   for (i = 0; i < num_peers; i++)
     peers[i].id = i;
 
-  GNUNET_CONFIGURATION_set_value_number(cfg,
-                                        "TESTBED", "OVERLAY_RANDOM_LINKS",
-                                        num_peers * 20);
-  GNUNET_CONFIGURATION_set_value_number(cfg,
-                                        "DHT", "FORCE_NSE",
-                                        (long long unsigned)
-                                        (log(num_peers) / log(2.0)));
+  GNUNET_CONFIGURATION_set_value_number (cfg,
+                                         "TESTBED", "OVERLAY_RANDOM_LINKS",
+                                         num_peers * 20);
+  GNUNET_CONFIGURATION_set_value_number (cfg,
+                                         "DHT", "FORCE_NSE",
+                                         (long long unsigned)
+                                         (log (num_peers) / log (2.0)));
   event_mask = 0LL;
 /* For feedback about the start process activate these and pass master_cb */
   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
 //   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
   event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
 //   event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
-  prof_start_time = GNUNET_TIME_absolute_get();
-  GNUNET_TESTBED_run(hosts_file,
-                     cfg,
-                     num_peers,
-                     event_mask,
-                     &master_controller_cb,
-                     NULL,      /* master_controller_cb cls */
-                     &test_master,
-                     NULL);     /* test_master cls */
+  prof_start_time = GNUNET_TIME_absolute_get ();
+  GNUNET_TESTBED_run (hosts_file,
+                      cfg,
+                      num_peers,
+                      event_mask,
+                      &master_controller_cb,
+                      NULL,     /* master_controller_cb cls */
+                      &test_master,
+                      NULL);    /* test_master cls */
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time(cfg, "TESTBED",
-                                          "SETUP_TIMEOUT",
-                                          &abort_time))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "SETUP_TIMEOUT not given. Using 15 minutes.\n");
-      abort_time =
-        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15);
-    }
-  abort_time = GNUNET_TIME_relative_add(abort_time, GNUNET_TIME_UNIT_MINUTES);
+      GNUNET_CONFIGURATION_get_value_time (cfg, "TESTBED",
+                                           "SETUP_TIMEOUT",
+                                           &abort_time))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "SETUP_TIMEOUT not given. Using 15 minutes.\n");
+    abort_time =
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15);
+  }
+  abort_time = GNUNET_TIME_relative_add (abort_time, GNUNET_TIME_UNIT_MINUTES);
   abort_task =
-    GNUNET_SCHEDULER_add_delayed(abort_time,
-                                 &do_abort,
-                                 (void*)__LINE__);
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             "setup_timeout: %s\n",
-             GNUNET_STRINGS_relative_time_to_string(abort_time, GNUNET_YES));
+    GNUNET_SCHEDULER_add_delayed (abort_time,
+                                  &do_abort,
+                                  (void*) __LINE__);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "setup_timeout: %s\n",
+              GNUNET_STRINGS_relative_time_to_string (abort_time, GNUNET_YES));
 }
 
 
@@ -1546,52 +1552,56 @@ run(void *cls,
  * @return 0 on success
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_filename('o',
-                                  "output-file",
-                                  "FILENAME",
-                                  gettext_noop("name of the file for writing statistics"),
-                                  &data_filename),
-
-    GNUNET_GETOPT_option_relative_time('t',
-                                       "matching-timeout",
-                                       "TIMEOUT",
-                                       gettext_noop("wait TIMEOUT before ending the experiment"),
-                                       &search_timeout_time),
-
-    GNUNET_GETOPT_option_filename('p',
-                                  "policy-dir",
-                                  "DIRECTORY",
-                                  gettext_noop("directory with policy files"),
-                                  &policy_dir),
-
-
-    GNUNET_GETOPT_option_filename('s',
-                                  "strings-file",
-                                  "FILENAME",
-                                  gettext_noop("name of file with input strings"),
-                                  &strings_file),
-
-    GNUNET_GETOPT_option_filename('H',
-                                  "hosts-file",
-                                  "FILENAME",
-                                  gettext_noop("name of file with hosts' names"),
-                                  &hosts_file),
+    GNUNET_GETOPT_option_filename ('o',
+                                   "output-file",
+                                   "FILENAME",
+                                   gettext_noop (
+                                     "name of the file for writing statistics"),
+                                   &data_filename),
+
+    GNUNET_GETOPT_option_relative_time ('t',
+                                        "matching-timeout",
+                                        "TIMEOUT",
+                                        gettext_noop (
+                                          "wait TIMEOUT before ending the experiment"),
+                                        &search_timeout_time),
+
+    GNUNET_GETOPT_option_filename ('p',
+                                   "policy-dir",
+                                   "DIRECTORY",
+                                   gettext_noop ("directory with policy files"),
+                                   &policy_dir),
+
+
+    GNUNET_GETOPT_option_filename ('s',
+                                   "strings-file",
+                                   "FILENAME",
+                                   gettext_noop (
+                                     "name of file with input strings"),
+                                   &strings_file),
+
+    GNUNET_GETOPT_option_filename ('H',
+                                   "hosts-file",
+                                   "FILENAME",
+                                   gettext_noop (
+                                     "name of file with hosts' names"),
+                                   &hosts_file),
 
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
   result = GNUNET_SYSERR;
   ret =
-    GNUNET_PROGRAM_run(argc, argv,
-                       "gnunet-regex-profiler",
-                       _("Profiler for regex"),
-                       options, &run, NULL);
+    GNUNET_PROGRAM_run (argc, argv,
+                        "gnunet-regex-profiler",
+                        _ ("Profiler for regex"),
+                        options, &run, NULL);
   if (GNUNET_OK != ret)
     return ret;
   if (GNUNET_OK != result)