global reindent, now with uncrustify hook enabled

8 files changed, 1154 insertions, 1145 deletions

diff --git a/src/nse/gnunet-nse-profiler.c b/src/nse/gnunet-nse-profiler.c
index eaa06b8ed..c97798772 100644
--- a/src/nse/gnunet-nse-profiler.c
+++ b/src/nse/gnunet-nse-profiler.c
@@ -36,18 +36,19 @@
 /**
  * Generic loggins shorthand
  */
-#define LOG(kind, ...) GNUNET_log(kind, __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
 
 /**
  * Debug logging shorthand
  */
-#define LOG_DEBUG(...) LOG(GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
+#define LOG_DEBUG(...) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
 
 
 /**
  * Information we track for a peer in the testbed.
  */
-struct NSEPeer {
+struct NSEPeer
+{
   /**
    * Prev reference in DLL.
    */
@@ -83,7 +84,8 @@ struct NSEPeer {
 /**
  * Operation map entry
  */
-struct OpListEntry {
+struct OpListEntry
+{
   /**
    * DLL next ptr
    */
@@ -229,26 +231,26 @@ static struct GNUNET_SCHEDULER_Task *round_task;
  * STATISTICS that we keep to selected peers.
  */
 static void
-close_monitor_connections()
+close_monitor_connections ()
 {
   struct NSEPeer *pos;
   struct OpListEntry *oplist_entry;
 
   while (NULL != (pos = peer_head))
-    {
-      if (NULL != pos->nse_op)
-        GNUNET_TESTBED_operation_done(pos->nse_op);
-      if (NULL != pos->stat_op)
-        GNUNET_TESTBED_operation_done(pos->stat_op);
-      GNUNET_CONTAINER_DLL_remove(peer_head, peer_tail, pos);
-      GNUNET_free(pos);
-    }
+  {
+    if (NULL != pos->nse_op)
+      GNUNET_TESTBED_operation_done (pos->nse_op);
+    if (NULL != pos->stat_op)
+      GNUNET_TESTBED_operation_done (pos->stat_op);
+    GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, pos);
+    GNUNET_free (pos);
+  }
   while (NULL != (oplist_entry = oplist_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(oplist_head, oplist_tail, oplist_entry);
-      GNUNET_TESTBED_operation_done(oplist_entry->op);
-      GNUNET_free(oplist_entry);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, oplist_entry);
+    GNUNET_TESTBED_operation_done (oplist_entry->op);
+    GNUNET_free (oplist_entry);
+  }
 }
 
 
@@ -258,30 +260,30 @@ close_monitor_connections()
  * @param cls unused
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
-  LOG_DEBUG("Ending test.\n");
-  close_monitor_connections();
+  LOG_DEBUG ("Ending test.\n");
+  close_monitor_connections ();
   if (NULL != round_task)
-    {
-      GNUNET_SCHEDULER_cancel(round_task);
-      round_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (round_task);
+    round_task = NULL;
+  }
   if (NULL != data_file)
-    {
-      GNUNET_DISK_file_close(data_file);
-      data_file = NULL;
-    }
+  {
+    GNUNET_DISK_file_close (data_file);
+    data_file = NULL;
+  }
   if (NULL != output_file)
-    {
-      GNUNET_DISK_file_close(output_file);
-      output_file = NULL;
-    }
+  {
+    GNUNET_DISK_file_close (output_file);
+    output_file = NULL;
+  }
   if (NULL != testing_cfg)
-    {
-      GNUNET_CONFIGURATION_destroy(testing_cfg);
-      testing_cfg = NULL;
-    }
+  {
+    GNUNET_CONFIGURATION_destroy (testing_cfg);
+    testing_cfg = NULL;
+  }
 }
 
 
@@ -295,35 +297,35 @@ shutdown_task(void *cls)
  *                of the size estimation values seen
  */
 static void
-handle_estimate(void *cls,
-                struct GNUNET_TIME_Absolute timestamp,
-                double estimate,
-                double std_dev)
+handle_estimate (void *cls,
+                 struct GNUNET_TIME_Absolute timestamp,
+                 double estimate,
+                 double std_dev)
 {
   struct NSEPeer *peer = cls;
   char output_buffer[512];
   size_t size;
 
   if (NULL == output_file)
-    {
-      fprintf(stderr,
-              "Received network size estimate from peer %p. Size: %f std.dev. %f\n",
-              peer,
-              estimate,
-              std_dev);
-      return;
-    }
-  size = GNUNET_snprintf(output_buffer,
-                         sizeof(output_buffer),
-                         "%p %llu %llu %f %f %f\n",
-                         peer,
-                         peers_running,
-                         (unsigned long long)timestamp.abs_value_us,
-                         GNUNET_NSE_log_estimate_to_n(estimate),
-                         estimate,
-                         std_dev);
-  if (size != GNUNET_DISK_file_write(output_file, output_buffer, size))
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+  {
+    fprintf (stderr,
+             "Received network size estimate from peer %p. Size: %f std.dev. %f\n",
+             peer,
+             estimate,
+             std_dev);
+    return;
+  }
+  size = GNUNET_snprintf (output_buffer,
+                          sizeof(output_buffer),
+                          "%p %llu %llu %f %f %f\n",
+                          peer,
+                          peers_running,
+                          (unsigned long long) timestamp.abs_value_us,
+                          GNUNET_NSE_log_estimate_to_n (estimate),
+                          estimate,
+                          std_dev);
+  if (size != GNUNET_DISK_file_write (output_file, output_buffer, size))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
 }
 
 
@@ -338,11 +340,11 @@ handle_estimate(void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-nse_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+nse_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct NSEPeer *current_peer = cls;
 
-  return GNUNET_NSE_connect(cfg, &handle_estimate, current_peer);
+  return GNUNET_NSE_connect (cfg, &handle_estimate, current_peer);
 }
 
 
@@ -354,9 +356,9 @@ nse_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param op_result service handle returned from the connect adapter
  */
 static void
-nse_disconnect_adapter(void *cls, void *op_result)
+nse_disconnect_adapter (void *cls, void *op_result)
 {
-  GNUNET_NSE_disconnect(op_result);
+  GNUNET_NSE_disconnect (op_result);
 }
 
 
@@ -371,40 +373,40 @@ nse_disconnect_adapter(void *cls, void *op_result)
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-stat_iterator(void *cls,
-              const char *subsystem,
-              const char *name,
-              uint64_t value,
-              int is_persistent)
+stat_iterator (void *cls,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
 {
   char *output_buffer;
   struct GNUNET_TIME_Absolute now;
   int size;
   unsigned int flag;
 
-  GNUNET_assert(NULL != data_file);
-  now = GNUNET_TIME_absolute_get();
-  flag = strcasecmp(subsystem, "core");
+  GNUNET_assert (NULL != data_file);
+  now = GNUNET_TIME_absolute_get ();
+  flag = strcasecmp (subsystem, "core");
   if (0 != flag)
     flag = 1;
-  size = GNUNET_asprintf(&output_buffer,
-                         "%llu %llu %u\n",
-                         now.abs_value_us / 1000LL / 1000LL,
-                         value,
-                         flag);
+  size = GNUNET_asprintf (&output_buffer,
+                          "%llu %llu %u\n",
+                          now.abs_value_us / 1000LL / 1000LL,
+                          value,
+                          flag);
   if (0 > size)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error formatting output buffer.\n");
-      GNUNET_free(output_buffer);
-      return GNUNET_SYSERR;
-    }
-  if (size != GNUNET_DISK_file_write(data_file, output_buffer, (size_t)size))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
-      GNUNET_free(output_buffer);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(output_buffer);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Error formatting output buffer.\n");
+    GNUNET_free (output_buffer);
+    return GNUNET_SYSERR;
+  }
+  if (size != GNUNET_DISK_file_write (data_file, output_buffer, (size_t) size))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+    GNUNET_free (output_buffer);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (output_buffer);
   return GNUNET_OK;
 }
 
@@ -419,11 +421,11 @@ stat_iterator(void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-stat_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+stat_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct NSEPeer *peer = cls;
 
-  peer->sh = GNUNET_STATISTICS_create("nse-profiler", cfg);
+  peer->sh = GNUNET_STATISTICS_create ("nse-profiler", cfg);
   return peer->sh;
 }
 
@@ -435,23 +437,23 @@ stat_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param op_result service handle returned from the connect adapter
  */
 static void
-stat_disconnect_adapter(void *cls, void *op_result)
+stat_disconnect_adapter (void *cls, void *op_result)
 {
   struct NSEPeer *peer = cls;
 
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_STATISTICS_watch_cancel(peer->sh,
-                                              "core",
-                                              "# peers connected",
-                                              stat_iterator,
-                                              peer));
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_STATISTICS_watch_cancel(peer->sh,
-                                              "nse",
-                                              "# peers connected",
-                                              stat_iterator,
-                                              peer));
-  GNUNET_STATISTICS_destroy(op_result, GNUNET_NO);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_STATISTICS_watch_cancel (peer->sh,
+                                                "core",
+                                                "# peers connected",
+                                                stat_iterator,
+                                                peer));
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_STATISTICS_watch_cancel (peer->sh,
+                                                "nse",
+                                                "# peers connected",
+                                                stat_iterator,
+                                                peer));
+  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
   peer->sh = NULL;
 }
 
@@ -467,29 +469,29 @@ stat_disconnect_adapter(void *cls, void *op_result)
  *          operation has executed successfully.
  */
 static void
-stat_comp_cb(void *cls,
-             struct GNUNET_TESTBED_Operation *op,
-             void *ca_result,
-             const char *emsg)
+stat_comp_cb (void *cls,
+              struct GNUNET_TESTBED_Operation *op,
+              void *ca_result,
+              const char *emsg)
 {
   struct GNUNET_STATISTICS_Handle *sh = ca_result;
   struct NSEPeer *peer = cls;
 
   if (NULL != emsg)
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_break(GNUNET_OK == GNUNET_STATISTICS_watch(sh,
-                                                    "core",
-                                                    "# peers connected",
-                                                    stat_iterator,
-                                                    peer));
-  GNUNET_break(GNUNET_OK == GNUNET_STATISTICS_watch(sh,
-                                                    "nse",
-                                                    "# peers connected",
-                                                    stat_iterator,
-                                                    peer));
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch (sh,
+                                                      "core",
+                                                      "# peers connected",
+                                                      stat_iterator,
+                                                      peer));
+  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch (sh,
+                                                      "nse",
+                                                      "# peers connected",
+                                                      stat_iterator,
+                                                      peer));
 }
 
 
@@ -498,7 +500,7 @@ stat_comp_cb(void *cls,
  * all of the running peers.
  */
 static void
-connect_nse_service()
+connect_nse_service ()
 {
   struct NSEPeer *current_peer;
   unsigned int i;
@@ -506,39 +508,39 @@ connect_nse_service()
 
   if (0 == connection_limit)
     return;
-  LOG_DEBUG("Connecting to nse service of peers\n");
+  LOG_DEBUG ("Connecting to nse service of peers\n");
   connections = 0;
   for (i = 0; i < num_peers_in_round[current_round]; i++)
-    {
-      if ((num_peers_in_round[current_round] > connection_limit) &&
-          (0 != (i % (num_peers_in_round[current_round] / connection_limit))))
-        continue;
-      LOG_DEBUG("Connecting to nse service of peer %d\n", i);
-      current_peer = GNUNET_new(struct NSEPeer);
-      current_peer->daemon = daemons[i];
-      current_peer->nse_op =
-        GNUNET_TESTBED_service_connect(NULL,
-                                       current_peer->daemon,
-                                       "nse",
-                                       NULL,
-                                       NULL,
-                                       &nse_connect_adapter,
-                                       &nse_disconnect_adapter,
-                                       current_peer);
-      if (NULL != data_file)
-        current_peer->stat_op =
-          GNUNET_TESTBED_service_connect(NULL,
-                                         current_peer->daemon,
-                                         "statistics",
-                                         stat_comp_cb,
-                                         current_peer,
-                                         &stat_connect_adapter,
-                                         &stat_disconnect_adapter,
-                                         current_peer);
-      GNUNET_CONTAINER_DLL_insert(peer_head, peer_tail, current_peer);
-      if (++connections == connection_limit)
-        break;
-    }
+  {
+    if ((num_peers_in_round[current_round] > connection_limit) &&
+        (0 != (i % (num_peers_in_round[current_round] / connection_limit))))
+      continue;
+    LOG_DEBUG ("Connecting to nse service of peer %d\n", i);
+    current_peer = GNUNET_new (struct NSEPeer);
+    current_peer->daemon = daemons[i];
+    current_peer->nse_op =
+      GNUNET_TESTBED_service_connect (NULL,
+                                      current_peer->daemon,
+                                      "nse",
+                                      NULL,
+                                      NULL,
+                                      &nse_connect_adapter,
+                                      &nse_disconnect_adapter,
+                                      current_peer);
+    if (NULL != data_file)
+      current_peer->stat_op =
+        GNUNET_TESTBED_service_connect (NULL,
+                                        current_peer->daemon,
+                                        "statistics",
+                                        stat_comp_cb,
+                                        current_peer,
+                                        &stat_connect_adapter,
+                                        &stat_disconnect_adapter,
+                                        current_peer);
+    GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, current_peer);
+    if (++connections == connection_limit)
+      break;
+  }
 }
 
 
@@ -548,7 +550,7 @@ connect_nse_service()
  * @param cls NULL, unused
  */
 static void
-next_round(void *cls);
+next_round (void *cls);
 
 
 /**
@@ -559,11 +561,11 @@ next_round(void *cls);
  * @param cls unused, NULL
  */
 static void
-finish_round(void *cls)
+finish_round (void *cls)
 {
-  LOG(GNUNET_ERROR_TYPE_INFO, "Have %u connections\n", total_connections);
-  close_monitor_connections();
-  round_task = GNUNET_SCHEDULER_add_now(&next_round, NULL);
+  LOG (GNUNET_ERROR_TYPE_INFO, "Have %u connections\n", total_connections);
+  close_monitor_connections ();
+  round_task = GNUNET_SCHEDULER_add_now (&next_round, NULL);
 }
 
 
@@ -573,11 +575,11 @@ finish_round(void *cls)
  * specified delay before finishing the round).
  */
 static void
-run_round()
+run_round ()
 {
-  LOG_DEBUG("Running round %u\n", current_round);
-  connect_nse_service();
-  GNUNET_SCHEDULER_add_delayed(wait_time, &finish_round, NULL);
+  LOG_DEBUG ("Running round %u\n", current_round);
+  connect_nse_service ();
+  GNUNET_SCHEDULER_add_delayed (wait_time, &finish_round, NULL);
 }
 
 
@@ -585,12 +587,12 @@ run_round()
  * Creates an oplist entry and adds it to the oplist DLL
  */
 static struct OpListEntry *
-make_oplist_entry()
+make_oplist_entry ()
 {
   struct OpListEntry *entry;
 
-  entry = GNUNET_new(struct OpListEntry);
-  GNUNET_CONTAINER_DLL_insert_tail(oplist_head, oplist_tail, entry);
+  entry = GNUNET_new (struct OpListEntry);
+  GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
   return entry;
 }
 
@@ -603,25 +605,25 @@ make_oplist_entry()
  * @param emsg NULL on success; otherwise an error description
  */
 static void
-manage_service_cb(void *cls,
-                  struct GNUNET_TESTBED_Operation *op,
-                  const char *emsg)
+manage_service_cb (void *cls,
+                   struct GNUNET_TESTBED_Operation *op,
+                   const char *emsg)
 {
   struct OpListEntry *entry = cls;
 
-  GNUNET_TESTBED_operation_done(entry->op);
+  GNUNET_TESTBED_operation_done (entry->op);
   if (NULL != emsg)
-    {
-      LOG(GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop NSE at a peer\n");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GNUNET_assert(0 != entry->delta);
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop NSE at a peer\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_assert (0 != entry->delta);
   peers_running += entry->delta;
-  GNUNET_CONTAINER_DLL_remove(oplist_head, oplist_tail, entry);
-  GNUNET_free(entry);
+  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
+  GNUNET_free (entry);
   if (num_peers_in_round[current_round] == peers_running)
-    run_round();
+    run_round ();
 }
 
 
@@ -630,35 +632,35 @@ manage_service_cb(void *cls,
  * peers for the round
  */
 static void
-adjust_running_peers()
+adjust_running_peers ()
 {
   struct OpListEntry *entry;
   unsigned int i;
 
   /* start peers if we have too few */
   for (i = peers_running; i < num_peers_in_round[current_round]; i++)
-    {
-      entry = make_oplist_entry();
-      entry->delta = 1;
-      entry->op = GNUNET_TESTBED_peer_manage_service(NULL,
-                                                     daemons[i],
-                                                     "nse",
-                                                     &manage_service_cb,
-                                                     entry,
-                                                     1);
-    }
+  {
+    entry = make_oplist_entry ();
+    entry->delta = 1;
+    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
+                                                    daemons[i],
+                                                    "nse",
+                                                    &manage_service_cb,
+                                                    entry,
+                                                    1);
+  }
   /* stop peers if we have too many */
   for (i = num_peers_in_round[current_round]; i < peers_running; i++)
-    {
-      entry = make_oplist_entry();
-      entry->delta = -1;
-      entry->op = GNUNET_TESTBED_peer_manage_service(NULL,
-                                                     daemons[i],
-                                                     "nse",
-                                                     &manage_service_cb,
-                                                     entry,
-                                                     0);
-    }
+  {
+    entry = make_oplist_entry ();
+    entry->delta = -1;
+    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
+                                                    daemons[i],
+                                                    "nse",
+                                                    &manage_service_cb,
+                                                    entry,
+                                                    0);
+  }
 }
 
 
@@ -669,25 +671,25 @@ adjust_running_peers()
  * @param cls NULL, unused
  */
 static void
-next_round(void *cls)
+next_round (void *cls)
 {
   round_task = NULL;
-  LOG_DEBUG("Disconnecting nse service of peers\n");
+  LOG_DEBUG ("Disconnecting nse service of peers\n");
   current_round++;
   if (current_round == num_rounds)
-    {
-      /* this was the last round, terminate */
-      ok = 0;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    /* this was the last round, terminate */
+    ok = 0;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (num_peers_in_round[current_round] == peers_running)
-    {
-      /* no need to churn, just run next round */
-      run_round();
-      return;
-    }
-  adjust_running_peers();
+  {
+    /* no need to churn, just run next round */
+    run_round ();
+    return;
+  }
+  adjust_running_peers ();
 }
 
 
@@ -699,22 +701,22 @@ next_round(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:
-      total_connections++;
-      break;
-
-    case GNUNET_TESTBED_ET_DISCONNECT:
-      total_connections--;
-      break;
-
-    default:
-      break;
-    }
+  {
+  case GNUNET_TESTBED_ET_CONNECT:
+    total_connections++;
+    break;
+
+  case GNUNET_TESTBED_ET_DISCONNECT:
+    total_connections--;
+    break;
+
+  default:
+    break;
+  }
 }
 
 
@@ -732,28 +734,28 @@ master_controller_cb(void *cls,
  *          failed
  */
 static void
-test_master(void *cls,
-            struct GNUNET_TESTBED_RunHandle *h,
-            unsigned int num_peers_,
-            struct GNUNET_TESTBED_Peer **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 **peers,
+             unsigned int links_succeeded,
+             unsigned int links_failed)
 {
   if (NULL == peers)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   daemons = peers;
-  GNUNET_break(num_peers_ == num_peers);
+  GNUNET_break (num_peers_ == num_peers);
   peers_running = num_peers;
   if (num_peers_in_round[current_round] == peers_running)
-    {
-      /* no need to churn, just run the starting round */
-      run_round();
-      return;
-    }
-  adjust_running_peers();
+  {
+    /* no need to churn, just run the starting round */
+    run_round ();
+    return;
+  }
+  adjust_running_peers ();
 }
 
 
@@ -766,75 +768,75 @@ test_master(void *cls,
  * @param cfg configuration handle
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *tok;
   uint64_t event_mask;
   unsigned int num;
 
   ok = 1;
-  testing_cfg = GNUNET_CONFIGURATION_dup(cfg);
-  LOG_DEBUG("Starting daemons.\n");
+  testing_cfg = GNUNET_CONFIGURATION_dup (cfg);
+  LOG_DEBUG ("Starting daemons.\n");
   if (NULL == num_peer_spec)
+  {
+    fprintf (stderr, "You need to specify the number of peers to run\n");
+    return;
+  }
+  for (tok = strtok (num_peer_spec, ","); NULL != tok; tok = strtok (NULL, ","))
+  {
+    if (1 != sscanf (tok, "%u", &num))
     {
-      fprintf(stderr, "You need to specify the number of peers to run\n");
+      fprintf (stderr, "You need to specify numbers, not `%s'\n", tok);
       return;
     }
-  for (tok = strtok(num_peer_spec, ","); NULL != tok; tok = strtok(NULL, ","))
-    {
-      if (1 != sscanf(tok, "%u", &num))
-        {
-          fprintf(stderr, "You need to specify numbers, not `%s'\n", tok);
-          return;
-        }
-      if (0 == num)
-        {
-          fprintf(stderr, "Refusing to run a round with 0 peers\n");
-          return;
-        }
-      GNUNET_array_append(num_peers_in_round, num_rounds, num);
-      num_peers = GNUNET_MAX(num_peers, num);
-    }
-  if (0 == num_peers)
+    if (0 == num)
     {
-      fprintf(stderr, "Refusing to run a testbed with no rounds\n");
+      fprintf (stderr, "Refusing to run a round with 0 peers\n");
       return;
     }
+    GNUNET_array_append (num_peers_in_round, num_rounds, num);
+    num_peers = GNUNET_MAX (num_peers, num);
+  }
+  if (0 == num_peers)
+  {
+    fprintf (stderr, "Refusing to run a testbed with no rounds\n");
+    return;
+  }
   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);
+       (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);
 
   if ((NULL != output_filename) &&
       (NULL ==
-       (output_file = GNUNET_DISK_file_open(output_filename,
-                                            GNUNET_DISK_OPEN_READWRITE |
-                                            GNUNET_DISK_OPEN_CREATE,
-                                            GNUNET_DISK_PERM_USER_READ |
-                                            GNUNET_DISK_PERM_USER_WRITE))))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", output_filename);
+       (output_file = GNUNET_DISK_file_open (output_filename,
+                                             GNUNET_DISK_OPEN_READWRITE
+                                             | GNUNET_DISK_OPEN_CREATE,
+                                             GNUNET_DISK_PERM_USER_READ
+                                             | GNUNET_DISK_PERM_USER_WRITE))))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", output_filename);
   event_mask = 0LL;
   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);
-  GNUNET_TESTBED_run(hosts_file,
-                     cfg,
-                     num_peers,
-                     event_mask,
-                     master_controller_cb,
-                     NULL,  /* master_controller_cb cls */
-                     &test_master,
-                     NULL);  /* test_master cls */
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
+  GNUNET_TESTBED_run (hosts_file,
+                      cfg,
+                      num_peers,
+                      event_mask,
+                      master_controller_cb,
+                      NULL, /* master_controller_cb cls */
+                      &test_master,
+                      NULL); /* test_master cls */
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 }
 
 
@@ -844,73 +846,73 @@ 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_uint(
+  { GNUNET_GETOPT_option_uint (
       'C',
       "connections",
       "COUNT",
-      gettext_noop(
+      gettext_noop (
         "limit to the number of connections to NSE services, 0 for none"),
       &connection_limit),
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string (
       'd',
       "details",
       "FILENAME",
-      gettext_noop(
+      gettext_noop (
         "name of the file for writing connection information and statistics"),
       &data_filename),
 
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string (
       'H',
       "hosts",
       "FILENAME",
-      gettext_noop(
+      gettext_noop (
         "name of the file with the login information for the testbed"),
       &hosts_file),
 
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string (
       'o',
       "output",
       "FILENAME",
-      gettext_noop("name of the file for writing the main results"),
+      gettext_noop ("name of the file for writing the main results"),
       &output_filename),
 
 
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string (
       'p',
       "peers",
       "NETWORKSIZESPEC",
-      gettext_noop(
+      gettext_noop (
         "Number of peers to run in each round, separated by commas"),
       &num_peer_spec),
 
-    GNUNET_GETOPT_option_increment_uint(
+    GNUNET_GETOPT_option_increment_uint (
       'V',
       "verbose",
-      gettext_noop("be verbose (print progress information)"),
+      gettext_noop ("be verbose (print progress information)"),
       &verbose),
 
-    GNUNET_GETOPT_option_relative_time('w',
-                                       "wait",
-                                       "DELAY",
-                                       gettext_noop("delay between rounds"),
-                                       &wait_time),
+    GNUNET_GETOPT_option_relative_time ('w',
+                                        "wait",
+                                        "DELAY",
+                                        gettext_noop ("delay between rounds"),
+                                        &wait_time),
     GNUNET_GETOPT_OPTION_END };
 
-  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;
   if (
     GNUNET_OK !=
-    GNUNET_PROGRAM_run(argc,
-                       argv,
-                       "nse-profiler",
-                       gettext_noop(
-                         "Measure quality and performance of the NSE service."),
-                       options,
-                       &run,
-                       NULL))
+    GNUNET_PROGRAM_run (argc,
+                        argv,
+                        "nse-profiler",
+                        gettext_noop (
+                          "Measure quality and performance of the NSE service."),
+                        options,
+                        &run,
+                        NULL))
     ok = 1;
   return ok;
 }
diff --git a/src/nse/gnunet-nse.c b/src/nse/gnunet-nse.c
index 3735373b5..edb73c0fc 100644
--- a/src/nse/gnunet-nse.c
+++ b/src/nse/gnunet-nse.c
@@ -44,14 +44,14 @@ static int status;
  * @param cls NULL
  */
 static void
-do_shutdown(void *cls)
+do_shutdown (void *cls)
 {
-  (void)cls;
+  (void) cls;
   if (NULL != nse)
-    {
-      GNUNET_NSE_disconnect(nse);
-      nse = NULL;
-    }
+  {
+    GNUNET_NSE_disconnect (nse);
+    nse = NULL;
+  }
 }
 
 
@@ -65,19 +65,19 @@ do_shutdown(void *cls)
  *                of the size estimation values seen
  */
 static void
-handle_estimate(void *cls,
-                struct GNUNET_TIME_Absolute timestamp,
-                double estimate,
-                double std_dev)
+handle_estimate (void *cls,
+                 struct GNUNET_TIME_Absolute timestamp,
+                 double estimate,
+                 double std_dev)
 {
-  (void)cls;
+  (void) cls;
   status = 0;
-  fprintf(stdout,
-          "%llu %f %f %f\n",
-          (unsigned long long)timestamp.abs_value_us,
-          GNUNET_NSE_log_estimate_to_n(estimate),
-          estimate,
-          std_dev);
+  fprintf (stdout,
+           "%llu %f %f %f\n",
+           (unsigned long long) timestamp.abs_value_us,
+           GNUNET_NSE_log_estimate_to_n (estimate),
+           estimate,
+           std_dev);
 }
 
 
@@ -90,16 +90,16 @@ handle_estimate(void *cls,
  * @param cfg configuration handle
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  (void)cls;
-  (void)args;
-  (void)cfgfile;
-  nse = GNUNET_NSE_connect(cfg, &handle_estimate, NULL);
-  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
+  (void) cls;
+  (void) args;
+  (void) cfgfile;
+  nse = GNUNET_NSE_connect (cfg, &handle_estimate, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 }
 
 
@@ -109,7 +109,7 @@ run(void *cls,
  * @return 0 on success
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   static struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
@@ -117,14 +117,14 @@ main(int argc, char *const *argv)
 
   status = 1;
   if (GNUNET_OK !=
-      GNUNET_PROGRAM_run(argc,
-                         argv,
-                         "gnunet-nse",
-                         gettext_noop(
-                           "Show network size estimates from NSE service."),
-                         options,
-                         &run,
-                         NULL))
+      GNUNET_PROGRAM_run (argc,
+                          argv,
+                          "gnunet-nse",
+                          gettext_noop (
+                            "Show network size estimates from NSE service."),
+                          options,
+                          &run,
+                          NULL))
     return 2;
   return status;
 }
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c
index d71c62541..fe32dc30b 100644
--- a/src/nse/gnunet-service-nse.c
+++ b/src/nse/gnunet-service-nse.c
@@ -72,11 +72,11 @@
  * required. Corking OK.
  */
 #define NSE_PRIORITY                                       \
-  (GNUNET_MQ_PRIO_BACKGROUND | GNUNET_MQ_PREF_UNRELIABLE | \
-   GNUNET_MQ_PREF_CORK_ALLOWED)
+  (GNUNET_MQ_PRIO_BACKGROUND | GNUNET_MQ_PREF_UNRELIABLE   \
+   | GNUNET_MQ_PREF_CORK_ALLOWED)
 
 #if FREEBSD
-#define log2(a) (log(a) / log(2))
+#define log2(a) (log (a) / log (2))
 #endif
 
 /**
@@ -117,7 +117,8 @@ static struct GNUNET_BIO_WriteHandle *histogram;
 /**
  * Per-peer information.
  */
-struct NSEPeerEntry {
+struct NSEPeerEntry
+{
   /**
    * Core handle for sending messages to this peer.
    */
@@ -166,7 +167,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * peer's timer has run out before receiving a
  * valid reply from another peer.
  */
-struct GNUNET_NSE_FloodMessage {
+struct GNUNET_NSE_FloodMessage
+{
   /**
    * Type: #GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD
    */
@@ -317,7 +319,7 @@ static uint64_t my_proof;
  * @param em message to fill in
  */
 static void
-setup_estimate_message(struct GNUNET_NSE_ClientMessage *em)
+setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
 {
   double mean;
   double sum;
@@ -340,19 +342,19 @@ setup_estimate_message(struct GNUNET_NSE_ClientMessage *em)
   sumweight = 0.0;
   variance = 0.0;
   for (unsigned int i = 0; i < estimate_count; i++)
-    {
-      unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
+  {
+    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
-      val = htonl(size_estimate_messages[j].matching_bits);
-      weight = estimate_count + 1 - i;
+    val = htonl (size_estimate_messages[j].matching_bits);
+    weight = estimate_count + 1 - i;
 
-      temp = weight + sumweight;
-      q = val - mean;
-      r = q * weight / temp;
-      mean += r;
-      sum += sumweight * q * r;
-      sumweight = temp;
-    }
+    temp = weight + sumweight;
+    q = val - mean;
+    r = q * weight / temp;
+    mean += r;
+    sum += sumweight * q * r;
+    sumweight = temp;
+  }
   if (estimate_count > 0)
     variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0);
 #else
@@ -366,44 +368,44 @@ setup_estimate_message(struct GNUNET_NSE_ClientMessage *em)
   mean = 0.0;
 
   for (unsigned int i = 0; i < estimate_count; i++)
-    {
-      unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
+  {
+    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
-      val = htonl(size_estimate_messages[j].matching_bits);
-      sum += val;
-      vsq += val * val;
-    }
+    val = htonl (size_estimate_messages[j].matching_bits);
+    sum += val;
+    vsq += val * val;
+  }
   if (0 != estimate_count)
-    {
-      mean = sum / estimate_count;
-      variance = (vsq - mean * sum) /
-                 (estimate_count - 1.0); // terrible for numerical stability...
-    }
+  {
+    mean = sum / estimate_count;
+    variance = (vsq - mean * sum)
+               / (estimate_count - 1.0); // terrible for numerical stability...
+  }
 #endif
   if (variance >= 0)
-    std_dev = sqrt(variance);
+    std_dev = sqrt (variance);
   else
     std_dev = variance; /* must be infinity due to estimate_count == 0 */
   current_std_dev = std_dev;
   current_size_estimate = mean;
 
-  em->header.size = htons(sizeof(struct GNUNET_NSE_ClientMessage));
-  em->header.type = htons(GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
-  em->reserved = htonl(0);
-  em->timestamp = GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get());
+  em->header.size = htons (sizeof(struct GNUNET_NSE_ClientMessage));
+  em->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
+  em->reserved = htonl (0);
+  em->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
   {
     double se = mean - 0.332747;
-    unsigned int j = GNUNET_CONTAINER_multipeermap_size(peers);
+    unsigned int j = GNUNET_CONTAINER_multipeermap_size (peers);
     if (0 == j)
       j = 1; /* Avoid log2(0); can only happen if CORE didn't report
                 connection to self yet */
-    nsize = log2(j);
-    em->size_estimate = GNUNET_hton_double(GNUNET_MAX(se, nsize));
-    em->std_deviation = GNUNET_hton_double(std_dev);
-    GNUNET_STATISTICS_set(stats,
-                          "# nodes in the network (estimate)",
-                          (uint64_t)pow(2, GNUNET_MAX(se, nsize)),
-                          GNUNET_NO);
+    nsize = log2 (j);
+    em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
+    em->std_deviation = GNUNET_hton_double (std_dev);
+    GNUNET_STATISTICS_set (stats,
+                           "# nodes in the network (estimate)",
+                           (uint64_t) pow (2, GNUNET_MAX (se, nsize)),
+                           GNUNET_NO);
   }
 }
 
@@ -418,21 +420,21 @@ setup_estimate_message(struct GNUNET_NSE_ClientMessage *em)
  * @param message the message received
  */
 static void
-handle_start(void *cls, const struct GNUNET_MessageHeader *message)
+handle_start (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_MQ_Handle *mq;
   struct GNUNET_NSE_ClientMessage em;
   struct GNUNET_MQ_Envelope *env;
 
-  (void)message;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
-  mq = GNUNET_SERVICE_client_get_mq(client);
-  GNUNET_notification_context_add(nc, mq);
-  setup_estimate_message(&em);
-  env = GNUNET_MQ_msg_copy(&em.header);
-  GNUNET_MQ_send(mq, env);
-  GNUNET_SERVICE_client_continue(client);
+  (void) message;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
+  mq = GNUNET_SERVICE_client_get_mq (client);
+  GNUNET_notification_context_add (nc, mq);
+  setup_estimate_message (&em);
+  env = GNUNET_MQ_msg_copy (&em.header);
+  GNUNET_MQ_send (mq, env);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -443,16 +445,16 @@ handle_start(void *cls, const struct GNUNET_MessageHeader *message)
  * @param matching_bits number of matching bits to consider
  */
 static double
-get_matching_bits_delay(uint32_t matching_bits)
+get_matching_bits_delay (uint32_t matching_bits)
 {
   /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */
   // S is next_timestamp (ignored in return value)
   // f is frequency (gnunet_nse_interval)
   // x is matching_bits
   // p' is current_size_estimate
-  return ((double)gnunet_nse_interval.rel_value_us / (double)2.0) -
-         ((gnunet_nse_interval.rel_value_us / M_PI) *
-          atan(matching_bits - current_size_estimate));
+  return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0)
+         - ((gnunet_nse_interval.rel_value_us / M_PI)
+            * atan (matching_bits - current_size_estimate));
 }
 
 
@@ -463,21 +465,21 @@ get_matching_bits_delay(uint32_t matching_bits)
  * @return random delay to apply
  */
 static struct GNUNET_TIME_Relative
-get_delay_randomization(uint32_t matching_bits)
+get_delay_randomization (uint32_t matching_bits)
 {
 #if USE_RANDOM_DELAYS
   struct GNUNET_TIME_Relative ret;
   uint32_t i;
   double d;
 
-  d = get_matching_bits_delay(matching_bits);
-  i = (uint32_t)(d / (double)(hop_count_max + 1));
+  d = get_matching_bits_delay (matching_bits);
+  i = (uint32_t) (d / (double) (hop_count_max + 1));
   ret.rel_value_us = i;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Randomizing flood using latencies up to %s\n",
-             GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Randomizing flood using latencies up to %s\n",
+              GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
   ret.rel_value_us =
-    GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
+    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
   return ret;
 #else
   return GNUNET_TIME_UNIT_ZERO;
@@ -493,18 +495,18 @@ get_delay_randomization(uint32_t matching_bits)
  * @param result where to write the resulting hash
  */
 static void
-pow_hash(const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
+pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
 {
-  GNUNET_break(
-    0 == gcry_kdf_derive(buf,
-                         buf_len,
-                         GCRY_KDF_SCRYPT,
-                         1 /* subalgo */,
-                         "gnunet-proof-of-work",
-                         strlen("gnunet-proof-of-work"),
-                         2 /* iterations; keep cost of individual op small */,
-                         sizeof(struct GNUNET_HashCode),
-                         result));
+  GNUNET_break (
+    0 == gcry_kdf_derive (buf,
+                          buf_len,
+                          GCRY_KDF_SCRYPT,
+                          1 /* subalgo */,
+                          "gnunet-proof-of-work",
+                          strlen ("gnunet-proof-of-work"),
+                          2 /* iterations; keep cost of individual op small */,
+                          sizeof(struct GNUNET_HashCode),
+                          result));
 }
 
 
@@ -516,17 +518,17 @@ pow_hash(const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
  * @return number of matching bits
  */
 static uint32_t
-get_matching_bits(struct GNUNET_TIME_Absolute timestamp,
-                  const struct GNUNET_PeerIdentity *id)
+get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
+                   const struct GNUNET_PeerIdentity *id)
 {
   struct GNUNET_HashCode timestamp_hash;
   struct GNUNET_HashCode pid_hash;
 
-  GNUNET_CRYPTO_hash(&timestamp.abs_value_us,
-                     sizeof(timestamp.abs_value_us),
-                     &timestamp_hash);
-  GNUNET_CRYPTO_hash(id, sizeof(struct GNUNET_PeerIdentity), &pid_hash);
-  return GNUNET_CRYPTO_hash_matching_bits(&timestamp_hash, &pid_hash);
+  GNUNET_CRYPTO_hash (&timestamp.abs_value_us,
+                      sizeof(timestamp.abs_value_us),
+                      &timestamp_hash);
+  GNUNET_CRYPTO_hash (id, sizeof(struct GNUNET_PeerIdentity), &pid_hash);
+  return GNUNET_CRYPTO_hash_matching_bits (&timestamp_hash, &pid_hash);
 }
 
 
@@ -539,7 +541,7 @@ get_matching_bits(struct GNUNET_TIME_Absolute timestamp,
  * @return delay that should be applied
  */
 static struct GNUNET_TIME_Relative
-get_transmit_delay(int round_offset)
+get_transmit_delay (int round_offset)
 {
   struct GNUNET_TIME_Relative ret;
   struct GNUNET_TIME_Absolute tgt;
@@ -547,37 +549,37 @@ get_transmit_delay(int round_offset)
   uint32_t matching_bits;
 
   switch (round_offset)
-    {
-    case -1:
-      /* previous round is randomized between 0 and 50 ms */
+  {
+  case -1:
+    /* previous round is randomized between 0 and 50 ms */
 #if USE_RANDOM_DELAYS
-      ret.rel_value_us =
-        GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, 50);
+    ret.rel_value_us =
+      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50);
 #else
-      ret = GNUNET_TIME_UNIT_ZERO;
+    ret = GNUNET_TIME_UNIT_ZERO;
 #endif
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Transmitting previous round behind schedule in %s\n",
-                 GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
-      return ret;
-
-    case 0:
-      /* current round is based on best-known matching_bits */
-      matching_bits =
-        ntohl(size_estimate_messages[estimate_index].matching_bits);
-      dist_delay = get_matching_bits_delay(matching_bits);
-      dist_delay += get_delay_randomization(matching_bits).rel_value_us;
-      ret.rel_value_us = (uint64_t)dist_delay;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "For round %s, delay for %u matching bits is %s\n",
-                 GNUNET_STRINGS_absolute_time_to_string(current_timestamp),
-                 (unsigned int)matching_bits,
-                 GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
-      /* now consider round start time and add delay to it */
-      tgt = GNUNET_TIME_absolute_add(current_timestamp, ret);
-      return GNUNET_TIME_absolute_get_remaining(tgt);
-    }
-  GNUNET_break(0);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting previous round behind schedule in %s\n",
+                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
+    return ret;
+
+  case 0:
+    /* current round is based on best-known matching_bits */
+    matching_bits =
+      ntohl (size_estimate_messages[estimate_index].matching_bits);
+    dist_delay = get_matching_bits_delay (matching_bits);
+    dist_delay += get_delay_randomization (matching_bits).rel_value_us;
+    ret.rel_value_us = (uint64_t) dist_delay;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "For round %s, delay for %u matching bits is %s\n",
+                GNUNET_STRINGS_absolute_time_to_string (current_timestamp),
+                (unsigned int) matching_bits,
+                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
+    /* now consider round start time and add delay to it */
+    tgt = GNUNET_TIME_absolute_add (current_timestamp, ret);
+    return GNUNET_TIME_absolute_get_remaining (tgt);
+  }
+  GNUNET_break (0);
   return GNUNET_TIME_UNIT_FOREVER_REL;
 }
 
@@ -588,7 +590,7 @@ get_transmit_delay(int round_offset)
  * @param cls the `struct NSEPeerEntry *`
  */
 static void
-transmit_task_cb(void *cls)
+transmit_task_cb (void *cls)
 {
   struct NSEPeerEntry *peer_entry = cls;
   unsigned int idx;
@@ -597,51 +599,51 @@ transmit_task_cb(void *cls)
   peer_entry->transmit_task = NULL;
   idx = estimate_index;
   if (GNUNET_NO == peer_entry->previous_round)
-    {
-      idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
-      peer_entry->previous_round = GNUNET_YES;
-      peer_entry->transmit_task =
-        GNUNET_SCHEDULER_add_delayed(get_transmit_delay(0),
-                                     &transmit_task_cb,
-                                     peer_entry);
-    }
-  if ((0 == ntohl(size_estimate_messages[idx].hop_count)) &&
+  {
+    idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
+    peer_entry->previous_round = GNUNET_YES;
+    peer_entry->transmit_task =
+      GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),
+                                    &transmit_task_cb,
+                                    peer_entry);
+  }
+  if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
       (NULL != proof_task))
-    {
-      GNUNET_STATISTICS_update(stats,
-                               "# flood messages not generated (no proof yet)",
-                               1,
-                               GNUNET_NO);
-      return;
-    }
-  if (0 == ntohs(size_estimate_messages[idx].header.size))
-    {
-      GNUNET_STATISTICS_update(stats,
-                               "# flood messages not generated (lack of history)",
-                               1,
-                               GNUNET_NO);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "In round %s, sending to `%s' estimate with %u bits\n",
-             GNUNET_STRINGS_absolute_time_to_string(
-               GNUNET_TIME_absolute_ntoh(
-                 size_estimate_messages[idx].timestamp)),
-             GNUNET_i2s(peer_entry->id),
-             (unsigned int)ntohl(size_estimate_messages[idx].matching_bits));
-  if (0 == ntohl(size_estimate_messages[idx].hop_count))
-    GNUNET_STATISTICS_update(stats, "# flood messages started", 1, GNUNET_NO);
-  GNUNET_STATISTICS_update(stats,
-                           "# flood messages transmitted",
-                           1,
-                           GNUNET_NO);
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# flood messages not generated (no proof yet)",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  if (0 == ntohs (size_estimate_messages[idx].header.size))
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# flood messages not generated (lack of history)",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "In round %s, sending to `%s' estimate with %u bits\n",
+              GNUNET_STRINGS_absolute_time_to_string (
+                GNUNET_TIME_absolute_ntoh (
+                  size_estimate_messages[idx].timestamp)),
+              GNUNET_i2s (peer_entry->id),
+              (unsigned int) ntohl (size_estimate_messages[idx].matching_bits));
+  if (0 == ntohl (size_estimate_messages[idx].hop_count))
+    GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            "# flood messages transmitted",
+                            1,
+                            GNUNET_NO);
 #if ENABLE_NSE_HISTOGRAM
   peer_entry->transmitted_messages++;
   peer_entry->last_transmitted_size =
-    ntohl(size_estimate_messages[idx].matching_bits);
+    ntohl (size_estimate_messages[idx].matching_bits);
 #endif
-  env = GNUNET_MQ_msg_copy(&size_estimate_messages[idx].header);
-  GNUNET_MQ_send(peer_entry->mq, env);
+  env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header);
+  GNUNET_MQ_send (peer_entry->mq, env);
 }
 
 
@@ -652,12 +654,12 @@ transmit_task_cb(void *cls)
  * clients.
  */
 static void
-update_network_size_estimate()
+update_network_size_estimate ()
 {
   struct GNUNET_NSE_ClientMessage em;
 
-  setup_estimate_message(&em);
-  GNUNET_notification_context_broadcast(nc, &em.header, GNUNET_YES);
+  setup_estimate_message (&em);
+  GNUNET_notification_context_broadcast (nc, &em.header, GNUNET_YES);
 }
 
 
@@ -669,31 +671,31 @@ update_network_size_estimate()
  * @param ts timestamp to use
  */
 static void
-setup_flood_message(unsigned int slot, struct GNUNET_TIME_Absolute ts)
+setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts)
 {
   struct GNUNET_NSE_FloodMessage *fm;
   uint32_t matching_bits;
 
-  matching_bits = get_matching_bits(ts, &my_identity);
+  matching_bits = get_matching_bits (ts, &my_identity);
   fm = &size_estimate_messages[slot];
-  fm->header.size = htons(sizeof(struct GNUNET_NSE_FloodMessage));
-  fm->header.type = htons(GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
-  fm->hop_count = htonl(0);
-  fm->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
+  fm->header.size = htons (sizeof(struct GNUNET_NSE_FloodMessage));
+  fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
+  fm->hop_count = htonl (0);
+  fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
   fm->purpose.size =
-    htonl(sizeof(struct GNUNET_NSE_FloodMessage) -
-          sizeof(struct GNUNET_MessageHeader) - sizeof(uint32_t) -
-          sizeof(struct GNUNET_CRYPTO_EddsaSignature));
-  fm->matching_bits = htonl(matching_bits);
-  fm->timestamp = GNUNET_TIME_absolute_hton(ts);
+    htonl (sizeof(struct GNUNET_NSE_FloodMessage)
+           - sizeof(struct GNUNET_MessageHeader) - sizeof(uint32_t)
+           - sizeof(struct GNUNET_CRYPTO_EddsaSignature));
+  fm->matching_bits = htonl (matching_bits);
+  fm->timestamp = GNUNET_TIME_absolute_hton (ts);
   fm->origin = my_identity;
   fm->proof_of_work = my_proof;
   if (nse_work_required > 0)
-    GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key,
-                                                        &fm->purpose,
-                                                        &fm->signature));
+    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key,
+                                                          &fm->purpose,
+                                                          &fm->signature));
   else
-    memset(&fm->signature, 0, sizeof(fm->signature));
+    memset (&fm->signature, 0, sizeof(fm->signature));
 }
 
 
@@ -707,34 +709,34 @@ setup_flood_message(unsigned int slot, struct GNUNET_TIME_Absolute ts)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-schedule_current_round(void *cls,
-                       const struct GNUNET_PeerIdentity *key,
-                       void *value)
+schedule_current_round (void *cls,
+                        const struct GNUNET_PeerIdentity *key,
+                        void *value)
 {
   struct NSEPeerEntry *peer_entry = value;
   struct GNUNET_TIME_Relative delay;
 
-  (void)cls;
-  (void)key;
+  (void) cls;
+  (void) key;
   if (NULL != peer_entry->transmit_task)
-    {
-      GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
-      peer_entry->previous_round = GNUNET_NO;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
+    peer_entry->previous_round = GNUNET_NO;
+  }
 #if ENABLE_NSE_HISTOGRAM
   if (peer_entry->received_messages > 1)
-    GNUNET_STATISTICS_update(stats,
-                             "# extra messages",
-                             peer_entry->received_messages - 1,
-                             GNUNET_NO);
+    GNUNET_STATISTICS_update (stats,
+                              "# extra messages",
+                              peer_entry->received_messages - 1,
+                              GNUNET_NO);
   peer_entry->transmitted_messages = 0;
   peer_entry->last_transmitted_size = 0;
   peer_entry->received_messages = 0;
 #endif
   delay =
-    get_transmit_delay((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
+    get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
   peer_entry->transmit_task =
-    GNUNET_SCHEDULER_add_delayed(delay, &transmit_task_cb, peer_entry);
+    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
   return GNUNET_OK;
 }
 
@@ -745,46 +747,46 @@ schedule_current_round(void *cls,
  * @param cls unused
  */
 static void
-update_flood_message(void *cls)
+update_flood_message (void *cls)
 {
   struct GNUNET_TIME_Relative offset;
 
-  (void)cls;
+  (void) cls;
   flood_task = NULL;
-  offset = GNUNET_TIME_absolute_get_remaining(next_timestamp);
+  offset = GNUNET_TIME_absolute_get_remaining (next_timestamp);
   if (0 != offset.rel_value_us)
-    {
-      /* somehow run early, delay more */
-      flood_task =
-        GNUNET_SCHEDULER_add_delayed(offset, &update_flood_message, NULL);
-      return;
-    }
+  {
+    /* somehow run early, delay more */
+    flood_task =
+      GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL);
+    return;
+  }
   estimate_index = (estimate_index + 1) % HISTORY_SIZE;
   if (estimate_count < HISTORY_SIZE)
     estimate_count++;
   current_timestamp = next_timestamp;
   next_timestamp =
-    GNUNET_TIME_absolute_add(current_timestamp, gnunet_nse_interval);
+    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
   if ((current_timestamp.abs_value_us ==
-       GNUNET_TIME_absolute_ntoh(next_message.timestamp).abs_value_us) &&
-      (get_matching_bits(current_timestamp, &my_identity) <
-       ntohl(next_message.matching_bits)))
-    {
-      /* we received a message for this round way early, use it! */
-      size_estimate_messages[estimate_index] = next_message;
-      size_estimate_messages[estimate_index].hop_count =
-        htonl(1 + ntohl(next_message.hop_count));
-    }
+       GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) &&
+      (get_matching_bits (current_timestamp, &my_identity) <
+       ntohl (next_message.matching_bits)))
+  {
+    /* we received a message for this round way early, use it! */
+    size_estimate_messages[estimate_index] = next_message;
+    size_estimate_messages[estimate_index].hop_count =
+      htonl (1 + ntohl (next_message.hop_count));
+  }
   else
-    setup_flood_message(estimate_index, current_timestamp);
-  next_message.matching_bits = htonl(0);  /* reset for 'next' round */
+    setup_flood_message (estimate_index, current_timestamp);
+  next_message.matching_bits = htonl (0);  /* reset for 'next' round */
   hop_count_max = 0;
   for (unsigned int i = 0; i < HISTORY_SIZE; i++)
     hop_count_max =
-      GNUNET_MAX(ntohl(size_estimate_messages[i].hop_count), hop_count_max);
-  GNUNET_CONTAINER_multipeermap_iterate(peers, &schedule_current_round, NULL);
+      GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
+  GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL);
   flood_task =
-    GNUNET_SCHEDULER_add_at(next_timestamp, &update_flood_message, NULL);
+    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
 }
 
 
@@ -795,12 +797,12 @@ update_flood_message(void *cls)
  * @return the number of leading zero bits.
  */
 static unsigned int
-count_leading_zeroes(const struct GNUNET_HashCode *hash)
+count_leading_zeroes (const struct GNUNET_HashCode *hash)
 {
   unsigned int hash_count;
 
   hash_count = 0;
-  while (0 == GNUNET_CRYPTO_hash_get_bit(hash, hash_count))
+  while (0 == GNUNET_CRYPTO_hash_get_bit (hash, hash_count))
     hash_count++;
   return hash_count;
 }
@@ -815,19 +817,19 @@ count_leading_zeroes(const struct GNUNET_HashCode *hash)
  * @return #GNUNET_YES if valid, #GNUNET_NO if not
  */
 static int
-check_proof_of_work(const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
-                    uint64_t val)
+check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
+                     uint64_t val)
 {
-  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) +
-           sizeof(val)] GNUNET_ALIGN;
+  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
+           + sizeof(val)] GNUNET_ALIGN;
   struct GNUNET_HashCode result;
 
-  GNUNET_memcpy(buf, &val, sizeof(val));
-  GNUNET_memcpy(&buf[sizeof(val)],
-                pkey,
-                sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
-  pow_hash(buf, sizeof(buf), &result);
-  return (count_leading_zeroes(&result) >= nse_work_required) ? GNUNET_YES
+  GNUNET_memcpy (buf, &val, sizeof(val));
+  GNUNET_memcpy (&buf[sizeof(val)],
+                 pkey,
+                 sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
+  pow_hash (buf, sizeof(buf), &result);
+  return (count_leading_zeroes (&result) >= nse_work_required) ? GNUNET_YES
          : GNUNET_NO;
 }
 
@@ -836,20 +838,20 @@ check_proof_of_work(const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
  * Write our current proof to disk.
  */
 static void
-write_proof()
+write_proof ()
 {
   char *proof;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename(cfg, "NSE", "PROOFFILE", &proof))
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
     return;
-  if (sizeof(my_proof) != GNUNET_DISK_fn_write(proof,
-                                               &my_proof,
-                                               sizeof(my_proof),
-                                               GNUNET_DISK_PERM_USER_READ |
-                                               GNUNET_DISK_PERM_USER_WRITE))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "write", proof);
-  GNUNET_free(proof);
+  if (sizeof(my_proof) != GNUNET_DISK_fn_write (proof,
+                                                &my_proof,
+                                                sizeof(my_proof),
+                                                GNUNET_DISK_PERM_USER_READ
+                                                | GNUNET_DISK_PERM_USER_WRITE))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", proof);
+  GNUNET_free (proof);
 }
 
 
@@ -859,57 +861,57 @@ write_proof()
  * @param cls closure (unused)
  */
 static void
-find_proof(void *cls)
+find_proof (void *cls)
 {
 #define ROUND_SIZE 10
   uint64_t counter;
-  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) +
-           sizeof(uint64_t)] GNUNET_ALIGN;
+  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
+           + sizeof(uint64_t)] GNUNET_ALIGN;
   struct GNUNET_HashCode result;
   unsigned int i;
 
-  (void)cls;
+  (void) cls;
   proof_task = NULL;
-  GNUNET_memcpy(&buf[sizeof(uint64_t)],
-                &my_identity,
-                sizeof(struct GNUNET_PeerIdentity));
+  GNUNET_memcpy (&buf[sizeof(uint64_t)],
+                 &my_identity,
+                 sizeof(struct GNUNET_PeerIdentity));
   i = 0;
   counter = my_proof;
   while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
+  {
+    GNUNET_memcpy (buf, &counter, sizeof(uint64_t));
+    pow_hash (buf, sizeof(buf), &result);
+    if (nse_work_required <= count_leading_zeroes (&result))
     {
-      GNUNET_memcpy(buf, &counter, sizeof(uint64_t));
-      pow_hash(buf, sizeof(buf), &result);
-      if (nse_work_required <= count_leading_zeroes(&result))
-        {
-          my_proof = counter;
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Proof of work found: %llu!\n",
-                     (unsigned long long)GNUNET_ntohll(counter));
-          write_proof();
-          setup_flood_message(estimate_index, current_timestamp);
-          return;
-        }
-      counter++;
-      i++;
-    }
-  if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Testing proofs currently at %llu\n",
-                 (unsigned long long)counter);
-      /* remember progress every 100 rounds */
       my_proof = counter;
-      write_proof();
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Proof of work found: %llu!\n",
+                  (unsigned long long) GNUNET_ntohll (counter));
+      write_proof ();
+      setup_flood_message (estimate_index, current_timestamp);
+      return;
     }
+    counter++;
+    i++;
+  }
+  if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Testing proofs currently at %llu\n",
+                (unsigned long long) counter);
+    /* remember progress every 100 rounds */
+    my_proof = counter;
+    write_proof ();
+  }
   else
-    {
-      my_proof = counter;
-    }
+  {
+    my_proof = counter;
+  }
   proof_task =
-    GNUNET_SCHEDULER_add_delayed_with_priority(proof_find_delay,
-                                               GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                               &find_proof,
-                                               NULL);
+    GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
+                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                &find_proof,
+                                                NULL);
 }
 
 
@@ -923,28 +925,28 @@ find_proof(void *cls)
  *         #GNUNET_NO if the key/signature don't verify
  */
 static int
-verify_message_crypto(const struct GNUNET_NSE_FloodMessage *incoming_flood)
+verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
 {
-  if (GNUNET_YES != check_proof_of_work(&incoming_flood->origin.public_key,
-                                        incoming_flood->proof_of_work))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Proof of work invalid: %llu!\n",
-                 (unsigned long long)GNUNET_ntohll(
-                   incoming_flood->proof_of_work));
-      GNUNET_break_op(0);
-      return GNUNET_NO;
-    }
+  if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key,
+                                         incoming_flood->proof_of_work))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Proof of work invalid: %llu!\n",
+                (unsigned long long) GNUNET_ntohll (
+                  incoming_flood->proof_of_work));
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
   if ((nse_work_required > 0) &&
       (GNUNET_OK !=
-       GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
-                                  &incoming_flood->purpose,
-                                  &incoming_flood->signature,
-                                  &incoming_flood->origin.public_key)))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_NO;
-    }
+       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
+                                   &incoming_flood->purpose,
+                                   &incoming_flood->signature,
+                                   &incoming_flood->origin.public_key)))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -959,35 +961,35 @@ verify_message_crypto(const struct GNUNET_NSE_FloodMessage *incoming_flood)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-update_flood_times(void *cls,
-                   const struct GNUNET_PeerIdentity *key,
-                   void *value)
+update_flood_times (void *cls,
+                    const struct GNUNET_PeerIdentity *key,
+                    void *value)
 {
   struct NSEPeerEntry *exclude = cls;
   struct NSEPeerEntry *peer_entry = value;
   struct GNUNET_TIME_Relative delay;
 
-  (void)key;
+  (void) key;
   if (peer_entry == exclude)
     return GNUNET_OK; /* trigger of the update */
   if (GNUNET_NO == peer_entry->previous_round)
+  {
+    /* still stuck in previous round, no point to update, check that
+     * we are active here though... */
+    if (NULL == peer_entry->transmit_task)
     {
-      /* still stuck in previous round, no point to update, check that
-       * we are active here though... */
-      if (NULL == peer_entry->transmit_task)
-        {
-          GNUNET_break(0);
-        }
-      return GNUNET_OK;
+      GNUNET_break (0);
     }
+    return GNUNET_OK;
+  }
   if (NULL != peer_entry->transmit_task)
-    {
-      GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
-      peer_entry->transmit_task = NULL;
-    }
-  delay = get_transmit_delay(0);
+  {
+    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
+    peer_entry->transmit_task = NULL;
+  }
+  delay = get_transmit_delay (0);
   peer_entry->transmit_task =
-    GNUNET_SCHEDULER_add_delayed(delay, &transmit_task_cb, peer_entry);
+    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
   return GNUNET_OK;
 }
 
@@ -999,8 +1001,8 @@ update_flood_times(void *cls,
  * @param incoming_flood received message
  */
 static void
-handle_p2p_estimate(void *cls,
-                    const struct GNUNET_NSE_FloodMessage *incoming_flood)
+handle_p2p_estimate (void *cls,
+                     const struct GNUNET_NSE_FloodMessage *incoming_flood)
 {
   struct NSEPeerEntry *peer_entry = cls;
   struct GNUNET_TIME_Absolute ts;
@@ -1011,157 +1013,157 @@ handle_p2p_estimate(void *cls,
   {
     uint64_t t;
 
-    t = GNUNET_TIME_absolute_get().abs_value_us;
+    t = GNUNET_TIME_absolute_get ().abs_value_us;
     if (NULL != lh)
-      GNUNET_TESTBED_LOGGER_write(lh, &t, sizeof(uint64_t));
+      GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof(uint64_t));
     if (NULL != histogram)
-      GNUNET_BIO_write_int64(histogram, t);
+      GNUNET_BIO_write_int64 (histogram, t);
   }
 #endif
-  GNUNET_STATISTICS_update(stats, "# flood messages received", 1, GNUNET_NO);
-  matching_bits = ntohl(incoming_flood->matching_bits);
+  GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO);
+  matching_bits = ntohl (incoming_flood->matching_bits);
 #if DEBUG_NSE
   {
     char origin[5];
     char pred[5];
     struct GNUNET_PeerIdentity os;
 
-    GNUNET_snprintf(origin,
-                    sizeof(origin),
-                    "%s",
-                    GNUNET_i2s(&incoming_flood->origin));
-    GNUNET_snprintf(pred, sizeof(pred), "%s", GNUNET_i2s(peer_entry->id));
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
-               GNUNET_STRINGS_absolute_time_to_string(
-                 GNUNET_TIME_absolute_ntoh(incoming_flood->timestamp)),
-               origin,
-               pred,
-               GNUNET_i2s(&my_identity),
-               (unsigned int)matching_bits);
+    GNUNET_snprintf (origin,
+                     sizeof(origin),
+                     "%s",
+                     GNUNET_i2s (&incoming_flood->origin));
+    GNUNET_snprintf (pred, sizeof(pred), "%s", GNUNET_i2s (peer_entry->id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
+                GNUNET_STRINGS_absolute_time_to_string (
+                  GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
+                origin,
+                pred,
+                GNUNET_i2s (&my_identity),
+                (unsigned int) matching_bits);
   }
 #endif
 
 #if ENABLE_NSE_HISTOGRAM
   peer_entry->received_messages++;
-  if (peer_entry->transmitted_messages > 0 &&
-      peer_entry->last_transmitted_size >= matching_bits)
-    GNUNET_STATISTICS_update(stats, "# cross messages", 1, GNUNET_NO);
+  if ((peer_entry->transmitted_messages > 0)&&
+      (peer_entry->last_transmitted_size >= matching_bits) )
+    GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO);
 #endif
 
-  ts = GNUNET_TIME_absolute_ntoh(incoming_flood->timestamp);
+  ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp);
   if (ts.abs_value_us == current_timestamp.abs_value_us)
     idx = estimate_index;
   else if (ts.abs_value_us ==
            current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us)
     idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
   else if (ts.abs_value_us == next_timestamp.abs_value_us)
+  {
+    if (matching_bits <= ntohl (next_message.matching_bits))
+      return;   /* ignore, simply too early/late */
+    if (GNUNET_YES != verify_message_crypto (incoming_flood))
     {
-      if (matching_bits <= ntohl(next_message.matching_bits))
-        return; /* ignore, simply too early/late */
-      if (GNUNET_YES != verify_message_crypto(incoming_flood))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Peer %s is likely ill-configured!\n",
-                     GNUNET_i2s(peer_entry->id));
-          GNUNET_break_op(0);
-          return;
-        }
-      next_message = *incoming_flood;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Peer %s is likely ill-configured!\n",
+                  GNUNET_i2s (peer_entry->id));
+      GNUNET_break_op (0);
       return;
     }
+    next_message = *incoming_flood;
+    return;
+  }
   else
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# flood messages discarded (clock skew too large)",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  if (0 == (GNUNET_memcmp (peer_entry->id, &my_identity)))
+  {
+    /* send to self, update our own estimate IF this also comes from us! */
+    if (0 == GNUNET_memcmp (&incoming_flood->origin, &my_identity))
+      update_network_size_estimate ();
+    return;
+  }
+  if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits))
+  {
+    /* Cancel transmission in the other direction, as this peer clearly has
+       up-to-date information already. Even if we didn't talk to this peer in
+       the previous round, we should no longer send it stale information as it
+       told us about the current round! */
+    peer_entry->previous_round = GNUNET_YES;
+    if (idx != estimate_index)
     {
-      GNUNET_STATISTICS_update(stats,
-                               "# flood messages discarded (clock skew too large)",
-                               1,
-                               GNUNET_NO);
-      return;
-    }
-  if (0 == (GNUNET_memcmp(peer_entry->id, &my_identity)))
-    {
-      /* send to self, update our own estimate IF this also comes from us! */
-      if (0 == GNUNET_memcmp(&incoming_flood->origin, &my_identity))
-        update_network_size_estimate();
-      return;
-    }
-  if (matching_bits == ntohl(size_estimate_messages[idx].matching_bits))
-    {
-      /* Cancel transmission in the other direction, as this peer clearly has
-         up-to-date information already. Even if we didn't talk to this peer in
-         the previous round, we should no longer send it stale information as it
-         told us about the current round! */
-      peer_entry->previous_round = GNUNET_YES;
-      if (idx != estimate_index)
-        {
-          /* do not transmit information for the previous round to this peer
-             anymore (but allow current round) */
-          return;
-        }
-      /* got up-to-date information for current round, cancel transmission to
-       * this peer altogether */
-      if (NULL != peer_entry->transmit_task)
-        {
-          GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
-          peer_entry->transmit_task = NULL;
-        }
+      /* do not transmit information for the previous round to this peer
+         anymore (but allow current round) */
       return;
     }
-  if (matching_bits < ntohl(size_estimate_messages[idx].matching_bits))
+    /* got up-to-date information for current round, cancel transmission to
+     * this peer altogether */
+    if (NULL != peer_entry->transmit_task)
     {
-      if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
-        {
-          peer_entry->previous_round = GNUNET_NO;
-        }
-      /* push back our result now, that peer is spreading bad information... */
-      if (NULL != peer_entry->transmit_task)
-        GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
-      peer_entry->transmit_task =
-        GNUNET_SCHEDULER_add_now(&transmit_task_cb, peer_entry);
-      /* Not closer than our most recent message, no need to do work here */
-      GNUNET_STATISTICS_update(stats,
-                               "# flood messages ignored (had closer already)",
-                               1,
-                               GNUNET_NO);
-      return;
+      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
+      peer_entry->transmit_task = NULL;
     }
-  if (GNUNET_YES != verify_message_crypto(incoming_flood))
+    return;
+  }
+  if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits))
+  {
+    if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
     {
-      GNUNET_break_op(0);
-      return;
+      peer_entry->previous_round = GNUNET_NO;
     }
-  GNUNET_assert(matching_bits >
-                ntohl(size_estimate_messages[idx].matching_bits));
+    /* push back our result now, that peer is spreading bad information... */
+    if (NULL != peer_entry->transmit_task)
+      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
+    peer_entry->transmit_task =
+      GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry);
+    /* Not closer than our most recent message, no need to do work here */
+    GNUNET_STATISTICS_update (stats,
+                              "# flood messages ignored (had closer already)",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  if (GNUNET_YES != verify_message_crypto (incoming_flood))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  GNUNET_assert (matching_bits >
+                 ntohl (size_estimate_messages[idx].matching_bits));
   /* Cancel transmission in the other direction, as this peer clearly has
    * up-to-date information already.
    */
   peer_entry->previous_round = GNUNET_YES;
   if (idx == estimate_index)
+  {
+    /* cancel any activity for current round */
+    if (NULL != peer_entry->transmit_task)
     {
-      /* cancel any activity for current round */
-      if (NULL != peer_entry->transmit_task)
-        {
-          GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
-          peer_entry->transmit_task = NULL;
-        }
+      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
+      peer_entry->transmit_task = NULL;
     }
+  }
   size_estimate_messages[idx] = *incoming_flood;
   size_estimate_messages[idx].hop_count =
-    htonl(ntohl(incoming_flood->hop_count) + 1);
+    htonl (ntohl (incoming_flood->hop_count) + 1);
   hop_count_max =
-    GNUNET_MAX(ntohl(incoming_flood->hop_count) + 1, hop_count_max);
-  GNUNET_STATISTICS_set(stats,
-                        "# estimated network diameter",
-                        hop_count_max,
-                        GNUNET_NO);
+    GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max);
+  GNUNET_STATISTICS_set (stats,
+                         "# estimated network diameter",
+                         hop_count_max,
+                         GNUNET_NO);
 
   /* have a new, better size estimate, inform clients */
-  update_network_size_estimate();
+  update_network_size_estimate ();
 
   /* flood to rest */
-  GNUNET_CONTAINER_multipeermap_iterate(peers,
-                                        &update_flood_times,
-                                        peer_entry);
+  GNUNET_CONTAINER_multipeermap_iterate (peers,
+                                         &update_flood_times,
+                                         peer_entry);
 }
 
 
@@ -1173,33 +1175,33 @@ handle_p2p_estimate(void *cls,
  * @param peer peer identity this notification is about
  */
 static void *
-handle_core_connect(void *cls,
-                    const struct GNUNET_PeerIdentity *peer,
-                    struct GNUNET_MQ_Handle *mq)
+handle_core_connect (void *cls,
+                     const struct GNUNET_PeerIdentity *peer,
+                     struct GNUNET_MQ_Handle *mq)
 {
   struct NSEPeerEntry *peer_entry;
 
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Peer `%s' connected to us\n",
-             GNUNET_i2s(peer));
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer `%s' connected to us\n",
+              GNUNET_i2s (peer));
   /* set our default transmission options */
-  GNUNET_MQ_set_options(mq, NSE_PRIORITY);
+  GNUNET_MQ_set_options (mq, NSE_PRIORITY);
   /* create our peer entry for this peer */
-  peer_entry = GNUNET_new(struct NSEPeerEntry);
+  peer_entry = GNUNET_new (struct NSEPeerEntry);
   peer_entry->id = peer;
   peer_entry->mq = mq;
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_put(
-                  peers,
-                  peer_entry->id,
-                  peer_entry,
-                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_put (
+                   peers,
+                   peer_entry->id,
+                   peer_entry,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   peer_entry->transmit_task =
-    GNUNET_SCHEDULER_add_delayed(get_transmit_delay(-1),
-                                 &transmit_task_cb,
-                                 peer_entry);
-  GNUNET_STATISTICS_update(stats, "# peers connected", 1, GNUNET_NO);
+    GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1),
+                                  &transmit_task_cb,
+                                  peer_entry);
+  GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO);
   return peer_entry;
 }
 
@@ -1213,25 +1215,25 @@ handle_core_connect(void *cls,
  * @parma internal_cls the `struct NSEPeerEntry` for the @a peer
  */
 static void
-handle_core_disconnect(void *cls,
-                       const struct GNUNET_PeerIdentity *peer,
-                       void *internal_cls)
+handle_core_disconnect (void *cls,
+                        const struct GNUNET_PeerIdentity *peer,
+                        void *internal_cls)
 {
   struct NSEPeerEntry *pos = internal_cls;
 
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Peer `%s' disconnected from us\n",
-             GNUNET_i2s(peer));
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(peers, peer, pos));
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer `%s' disconnected from us\n",
+              GNUNET_i2s (peer));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (peers, peer, pos));
   if (NULL != pos->transmit_task)
-    {
-      GNUNET_SCHEDULER_cancel(pos->transmit_task);
-      pos->transmit_task = NULL;
-    }
-  GNUNET_free(pos);
-  GNUNET_STATISTICS_update(stats, "# peers connected", -1, GNUNET_NO);
+  {
+    GNUNET_SCHEDULER_cancel (pos->transmit_task);
+    pos->transmit_task = NULL;
+  }
+  GNUNET_free (pos);
+  GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO);
 }
 
 
@@ -1244,11 +1246,11 @@ handle_core_disconnect(void *cls,
  * @param size the amount of data sent (ignored)
  */
 static void
-flush_comp_cb(void *cls, size_t size)
+flush_comp_cb (void *cls, size_t size)
 {
-  (void)cls;
-  (void)size;
-  GNUNET_TESTBED_LOGGER_disconnect(lh);
+  (void) cls;
+  (void) size;
+  GNUNET_TESTBED_LOGGER_disconnect (lh);
   lh = NULL;
 }
 #endif
@@ -1260,60 +1262,60 @@ flush_comp_cb(void *cls, size_t size)
  * @param cls unused
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
-  (void)cls;
+  (void) cls;
   if (NULL != flood_task)
-    {
-      GNUNET_SCHEDULER_cancel(flood_task);
-      flood_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (flood_task);
+    flood_task = NULL;
+  }
   if (NULL != proof_task)
-    {
-      GNUNET_SCHEDULER_cancel(proof_task);
-      proof_task = NULL;
-      write_proof(); /* remember progress */
-    }
+  {
+    GNUNET_SCHEDULER_cancel (proof_task);
+    proof_task = NULL;
+    write_proof ();  /* remember progress */
+  }
   if (NULL != nc)
-    {
-      GNUNET_notification_context_destroy(nc);
-      nc = NULL;
-    }
+  {
+    GNUNET_notification_context_destroy (nc);
+    nc = NULL;
+  }
   if (NULL != core_api)
-    {
-      GNUNET_CORE_disconnect(core_api);
-      core_api = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (core_api);
+    core_api = NULL;
+  }
   if (NULL != stats)
-    {
-      GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }
   if (NULL != peers)
-    {
-      GNUNET_CONTAINER_multipeermap_destroy(peers);
-      peers = NULL;
-    }
+  {
+    GNUNET_CONTAINER_multipeermap_destroy (peers);
+    peers = NULL;
+  }
   if (NULL != my_private_key)
-    {
-      GNUNET_free(my_private_key);
-      my_private_key = NULL;
-    }
+  {
+    GNUNET_free (my_private_key);
+    my_private_key = NULL;
+  }
 #if ENABLE_NSE_HISTOGRAM
   if (NULL != logger_test)
-    {
-      GNUNET_CLIENT_service_test_cancel(logger_test);
-      logger_test = NULL;
-    }
+  {
+    GNUNET_CLIENT_service_test_cancel (logger_test);
+    logger_test = NULL;
+  }
   if (NULL != lh)
-    {
-      GNUNET_TESTBED_LOGGER_flush(lh, &flush_comp_cb, NULL);
-    }
+  {
+    GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL);
+  }
   if (NULL != histogram)
-    {
-      GNUNET_BIO_write_close(histogram);
-      histogram = NULL;
-    }
+  {
+    GNUNET_BIO_write_close (histogram);
+    histogram = NULL;
+  }
 #endif
 }
 
@@ -1325,38 +1327,38 @@ shutdown_task(void *cls)
  * @param identity the public identity of this peer
  */
 static void
-core_init(void *cls, const struct GNUNET_PeerIdentity *identity)
+core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
 {
   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_Absolute prev_time;
 
-  (void)cls;
+  (void) cls;
   if (NULL == identity)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GNUNET_assert(0 == GNUNET_memcmp(&my_identity, identity));
-  now = GNUNET_TIME_absolute_get();
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_assert (0 == GNUNET_memcmp (&my_identity, identity));
+  now = GNUNET_TIME_absolute_get ();
   current_timestamp.abs_value_us =
-    (now.abs_value_us / gnunet_nse_interval.rel_value_us) *
-    gnunet_nse_interval.rel_value_us;
+    (now.abs_value_us / gnunet_nse_interval.rel_value_us)
+    * gnunet_nse_interval.rel_value_us;
   next_timestamp =
-    GNUNET_TIME_absolute_add(current_timestamp, gnunet_nse_interval);
+    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
   estimate_index = HISTORY_SIZE - 1;
   estimate_count = 0;
-  if (GNUNET_YES == check_proof_of_work(&my_identity.public_key, my_proof))
-    {
-      int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
-      prev_time.abs_value_us =
-        current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
-      setup_flood_message(idx, prev_time);
-      setup_flood_message(estimate_index, current_timestamp);
-      estimate_count++;
-    }
+  if (GNUNET_YES == check_proof_of_work (&my_identity.public_key, my_proof))
+  {
+    int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
+    prev_time.abs_value_us =
+      current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
+    setup_flood_message (idx, prev_time);
+    setup_flood_message (estimate_index, current_timestamp);
+    estimate_count++;
+  }
   flood_task =
-    GNUNET_SCHEDULER_add_at(next_timestamp, &update_flood_message, NULL);
+    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
 }
 
 
@@ -1370,21 +1372,21 @@ core_init(void *cls, const struct GNUNET_PeerIdentity *identity)
  *               #GNUNET_SYSERR if the configuration is invalid
  */
 static void
-status_cb(void *cls, int status)
+status_cb (void *cls, int status)
 {
-  (void)cls;
+  (void) cls;
   logger_test = NULL;
   if (GNUNET_YES != status)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
-      return;
-    }
-  if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect(cfg)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Cannot connect to the testbed logger.  Exiting.\n");
-      GNUNET_SCHEDULER_shutdown();
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
+    return;
+  }
+  if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Cannot connect to the testbed logger.  Exiting.\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
 }
 #endif
 
@@ -1397,127 +1399,127 @@ status_cb(void *cls, int status)
  * @param service the initialized service
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_SERVICE_Handle *service)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *service)
 {
   struct GNUNET_MQ_MessageHandler core_handlers[] =
-  { GNUNET_MQ_hd_fixed_size(p2p_estimate,
-                            GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
-                            struct GNUNET_NSE_FloodMessage,
-                            NULL),
-    GNUNET_MQ_handler_end() };
+  { GNUNET_MQ_hd_fixed_size (p2p_estimate,
+                             GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
+                             struct GNUNET_NSE_FloodMessage,
+                             NULL),
+    GNUNET_MQ_handler_end () };
   char *proof;
   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
 
-  (void)cls;
-  (void)service;
+  (void) cls;
+  (void) service;
   cfg = c;
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                       "NSE",
-                                                       "INTERVAL",
-                                                       &gnunet_nse_interval))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                       "NSE",
-                                                       "WORKDELAY",
-                                                       &proof_find_delay))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                         "NSE",
-                                                         "WORKBITS",
-                                                         &nse_work_required))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                        "NSE",
+                                                        "INTERVAL",
+                                                        &gnunet_nse_interval))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                        "NSE",
+                                                        "WORKDELAY",
+                                                        &proof_find_delay))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                          "NSE",
+                                                          "WORKBITS",
+                                                          &nse_work_required))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (nse_work_required >= sizeof(struct GNUNET_HashCode) * 8)
-    {
-      GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
-                                "NSE",
-                                "WORKBITS",
-                                _("Value is too large.\n"));
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
+                               "NSE",
+                               "WORKBITS",
+                               _ ("Value is too large.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 
 #if ENABLE_NSE_HISTOGRAM
   {
     char *histogram_dir;
     char *histogram_fn;
 
-    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                                             "NSE",
-                                                             "HISTOGRAM_DIR",
-                                                             &histogram_dir))
-      {
-        GNUNET_assert(
-          0 < GNUNET_asprintf(&histogram_fn, "%s/timestamps", histogram_dir));
-        GNUNET_free(histogram_dir);
-        histogram = GNUNET_BIO_write_open(histogram_fn);
-        if (NULL == histogram)
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                     "Unable to open histogram file `%s'\n",
-                     histogram_fn);
-        GNUNET_free(histogram_fn);
-      }
-    logger_test = GNUNET_CLIENT_service_test("testbed-logger",
-                                             cfg,
-                                             GNUNET_TIME_UNIT_SECONDS,
-                                             &status_cb,
-                                             NULL);
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                              "NSE",
+                                                              "HISTOGRAM_DIR",
+                                                              &histogram_dir))
+    {
+      GNUNET_assert (
+        0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir));
+      GNUNET_free (histogram_dir);
+      histogram = GNUNET_BIO_write_open (histogram_fn);
+      if (NULL == histogram)
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Unable to open histogram file `%s'\n",
+                    histogram_fn);
+      GNUNET_free (histogram_fn);
+    }
+    logger_test = GNUNET_CLIENT_service_test ("testbed-logger",
+                                              cfg,
+                                              GNUNET_TIME_UNIT_SECONDS,
+                                              &status_cb,
+                                              NULL);
   }
 #endif
 
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
-  pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg);
-  GNUNET_assert(NULL != pk);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+  GNUNET_assert (NULL != pk);
   my_private_key = pk;
-  GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key);
+  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename(cfg, "NSE", "PROOFFILE", &proof))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
-      GNUNET_free(my_private_key);
-      my_private_key = NULL;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  if ((GNUNET_YES != GNUNET_DISK_file_test(proof)) ||
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
+    GNUNET_free (my_private_key);
+    my_private_key = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
       (sizeof(my_proof) !=
-       GNUNET_DISK_fn_read(proof, &my_proof, sizeof(my_proof))))
+       GNUNET_DISK_fn_read (proof, &my_proof, sizeof(my_proof))))
     my_proof = 0;
-  GNUNET_free(proof);
+  GNUNET_free (proof);
   proof_task =
-    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                       &find_proof,
-                                       NULL);
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                        &find_proof,
+                                        NULL);
 
-  peers = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_YES);
-  nc = GNUNET_notification_context_create(1);
+  peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
+  nc = GNUNET_notification_context_create (1);
   /* Connect to core service and register core handlers */
   core_api =
-    GNUNET_CORE_connect(cfg,  /* Main configuration */
-                        NULL,  /* Closure passed to functions */
-                        &core_init,  /* Call core_init once connected */
-                        &handle_core_connect,  /* Handle connects */
-                        &handle_core_disconnect,  /* Handle disconnects */
-                        core_handlers);  /* Register these handlers */
+    GNUNET_CORE_connect (cfg,  /* Main configuration */
+                         NULL, /* Closure passed to functions */
+                         &core_init, /* Call core_init once connected */
+                         &handle_core_connect, /* Handle connects */
+                         &handle_core_disconnect, /* Handle disconnects */
+                         core_handlers); /* Register these handlers */
   if (NULL == core_api)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  stats = GNUNET_STATISTICS_create("nse", cfg);
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  stats = GNUNET_STATISTICS_create ("nse", cfg);
 }
 
 
@@ -1530,12 +1532,12 @@ run(void *cls,
  * @return @a c
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *c,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *c,
+                   struct GNUNET_MQ_Handle *mq)
 {
-  (void)cls;
-  (void)mq;
+  (void) cls;
+  (void) mq;
   return c;
 }
 
@@ -1548,29 +1550,29 @@ client_connect_cb(void *cls,
  * @param internal_cls should be equal to @a c
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *c,
-                     void *internal_cls)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *c,
+                      void *internal_cls)
 {
-  (void)cls;
-  GNUNET_assert(c == internal_cls);
+  (void) cls;
+  GNUNET_assert (c == internal_cls);
 }
 
 
 /**
  * Define "main" method using service macro.
  */
-GNUNET_SERVICE_MAIN("nse",
-                    GNUNET_SERVICE_OPTION_NONE,
-                    &run,
-                    &client_connect_cb,
-                    &client_disconnect_cb,
-                    NULL,
-                    GNUNET_MQ_hd_fixed_size(start,
-                                            GNUNET_MESSAGE_TYPE_NSE_START,
-                                            struct GNUNET_MessageHeader,
-                                            NULL),
-                    GNUNET_MQ_handler_end());
+GNUNET_SERVICE_MAIN ("nse",
+                     GNUNET_SERVICE_OPTION_NONE,
+                     &run,
+                     &client_connect_cb,
+                     &client_disconnect_cb,
+                     NULL,
+                     GNUNET_MQ_hd_fixed_size (start,
+                                              GNUNET_MESSAGE_TYPE_NSE_START,
+                                              struct GNUNET_MessageHeader,
+                                              NULL),
+                     GNUNET_MQ_handler_end ());
 
 
 #if defined(LINUX) && defined(__GLIBC__)
@@ -1579,11 +1581,11 @@ GNUNET_SERVICE_MAIN("nse",
 /**
  * MINIMIZE heap size (way below 128k) since this process doesn't need much.
  */
-void __attribute__ ((constructor)) GNUNET_ARM_memory_init()
+void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
 {
-  mallopt(M_TRIM_THRESHOLD, 4 * 1024);
-  mallopt(M_TOP_PAD, 1 * 1024);
-  malloc_trim(0);
+  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
+  mallopt (M_TOP_PAD, 1 * 1024);
+  malloc_trim (0);
 }
 #endif
 
diff --git a/src/nse/nse.h b/src/nse/nse.h
index b0129addd..5d1fccb7e 100644
--- a/src/nse/nse.h
+++ b/src/nse/nse.h
@@ -39,7 +39,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * standard deviation of known estimates.
  *
  */
-struct GNUNET_NSE_ClientMessage {
+struct GNUNET_NSE_ClientMessage
+{
   /**
    * Type: GNUNET_MESSAGE_TYPE_NSE_ESTIMATE
    */
diff --git a/src/nse/nse_api.c b/src/nse/nse_api.c
index 93716eb5f..af6a2065b 100644
--- a/src/nse/nse_api.c
+++ b/src/nse/nse_api.c
@@ -32,12 +32,13 @@
 #include "gnunet_nse_service.h"
 #include "nse.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "nse-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "nse-api", __VA_ARGS__)
 
 /**
  * Handle for talking with the NSE service.
  */
-struct GNUNET_NSE_Handle {
+struct GNUNET_NSE_Handle
+{
   /**
    * Configuration to use.
    */
@@ -76,7 +77,7 @@ struct GNUNET_NSE_Handle {
  * @param cls closure with the `struct GNUNET_NSE_Handle *`
  */
 static void
-reconnect(void *cls);
+reconnect (void *cls);
 
 
 /**
@@ -89,16 +90,16 @@ reconnect(void *cls);
  * @param error error code
  */
 static void
-mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
+mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_NSE_Handle *h = cls;
 
-  (void)error;
-  GNUNET_MQ_destroy(h->mq);
+  (void) error;
+  GNUNET_MQ_destroy (h->mq);
   h->mq = NULL;
   h->reconnect_task =
-    GNUNET_SCHEDULER_add_delayed(h->reconnect_delay, &reconnect, h);
-  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF(h->reconnect_delay);
+    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
+  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
 }
 
 
@@ -110,15 +111,15 @@ mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
  * @param client_msg message received
  */
 static void
-handle_estimate(void *cls, const struct GNUNET_NSE_ClientMessage *client_msg)
+handle_estimate (void *cls, const struct GNUNET_NSE_ClientMessage *client_msg)
 {
   struct GNUNET_NSE_Handle *h = cls;
 
   h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
-  h->recv_cb(h->recv_cb_cls,
-             GNUNET_TIME_absolute_ntoh(client_msg->timestamp),
-             GNUNET_ntoh_double(client_msg->size_estimate),
-             GNUNET_ntoh_double(client_msg->std_deviation));
+  h->recv_cb (h->recv_cb_cls,
+              GNUNET_TIME_absolute_ntoh (client_msg->timestamp),
+              GNUNET_ntoh_double (client_msg->size_estimate),
+              GNUNET_ntoh_double (client_msg->std_deviation));
 }
 
 
@@ -128,27 +129,27 @@ handle_estimate(void *cls, const struct GNUNET_NSE_ClientMessage *client_msg)
  * @param cls the `struct GNUNET_NSE_Handle *`
  */
 static void
-reconnect(void *cls)
+reconnect (void *cls)
 {
   struct GNUNET_NSE_Handle *h = cls;
   struct GNUNET_MQ_MessageHandler handlers[] =
-  { GNUNET_MQ_hd_fixed_size(estimate,
-                            GNUNET_MESSAGE_TYPE_NSE_ESTIMATE,
-                            struct GNUNET_NSE_ClientMessage,
-                            h),
-    GNUNET_MQ_handler_end() };
+  { GNUNET_MQ_hd_fixed_size (estimate,
+                             GNUNET_MESSAGE_TYPE_NSE_ESTIMATE,
+                             struct GNUNET_NSE_ClientMessage,
+                             h),
+    GNUNET_MQ_handler_end () };
   struct GNUNET_MessageHeader *msg;
   struct GNUNET_MQ_Envelope *env;
 
   h->reconnect_task = NULL;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Connecting to network size estimation service.\n");
-  GNUNET_assert(NULL == h->mq);
-  h->mq = GNUNET_CLIENT_connect(h->cfg, "nse", handlers, &mq_error_handler, h);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Connecting to network size estimation service.\n");
+  GNUNET_assert (NULL == h->mq);
+  h->mq = GNUNET_CLIENT_connect (h->cfg, "nse", handlers, &mq_error_handler, h);
   if (NULL == h->mq)
     return;
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NSE_START);
-  GNUNET_MQ_send(h->mq, env);
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NSE_START);
+  GNUNET_MQ_send (h->mq, env);
 }
 
 
@@ -161,24 +162,24 @@ reconnect(void *cls)
  * @return handle to use
  */
 struct GNUNET_NSE_Handle *
-GNUNET_NSE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                   GNUNET_NSE_Callback func,
-                   void *func_cls)
+GNUNET_NSE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                    GNUNET_NSE_Callback func,
+                    void *func_cls)
 {
   struct GNUNET_NSE_Handle *h;
 
-  GNUNET_assert(NULL != func);
-  h = GNUNET_new(struct GNUNET_NSE_Handle);
+  GNUNET_assert (NULL != func);
+  h = GNUNET_new (struct GNUNET_NSE_Handle);
   h->cfg = cfg;
   h->recv_cb = func;
   h->recv_cb_cls = func_cls;
   h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
-  reconnect(h);
+  reconnect (h);
   if (NULL == h->mq)
-    {
-      GNUNET_free(h);
-      return NULL;
-    }
+  {
+    GNUNET_free (h);
+    return NULL;
+  }
   return h;
 }
 
@@ -189,19 +190,19 @@ GNUNET_NSE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param h handle to destroy
  */
 void
-GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
+GNUNET_NSE_disconnect (struct GNUNET_NSE_Handle *h)
 {
   if (NULL != h->reconnect_task)
-    {
-      GNUNET_SCHEDULER_cancel(h->reconnect_task);
-      h->reconnect_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->reconnect_task);
+    h->reconnect_task = NULL;
+  }
   if (NULL != h->mq)
-    {
-      GNUNET_MQ_destroy(h->mq);
-      h->mq = NULL;
-    }
-  GNUNET_free(h);
+  {
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
+  }
+  GNUNET_free (h);
 }
 
 /* end of nse_api.c */
diff --git a/src/nse/perf_kdf.c b/src/nse/perf_kdf.c
index bf4dbe0b2..a6c1432c8 100644
--- a/src/nse/perf_kdf.c
+++ b/src/nse/perf_kdf.c
@@ -38,47 +38,49 @@
  * @param result where to write the resulting hash
  */
 static void
-pow_hash(const void *buf,
-         size_t buf_len,
-         struct GNUNET_HashCode *result)
+pow_hash (const void *buf,
+          size_t buf_len,
+          struct GNUNET_HashCode *result)
 {
-  GNUNET_break(0 ==
-               gcry_kdf_derive(buf, buf_len,
-                               GCRY_KDF_SCRYPT,
-                               1 /* subalgo */,
-                               "gnunet-proof-of-work", strlen("gnunet-proof-of-work"),
-                               2 /* iterations; keep cost of individual op small */,
-                               sizeof(struct GNUNET_HashCode), result));
+  GNUNET_break (0 ==
+                gcry_kdf_derive (buf, buf_len,
+                                 GCRY_KDF_SCRYPT,
+                                 1 /* subalgo */,
+                                 "gnunet-proof-of-work", strlen (
+                                   "gnunet-proof-of-work"),
+                                 2 /* iterations; keep cost of individual op small */,
+                                 sizeof(struct GNUNET_HashCode), result));
 }
 
 
 static void
-perfHash()
+perfHash ()
 {
   struct GNUNET_HashCode hc;
   unsigned int i;
   char buf[64];
 
-  memset(buf, 1, sizeof(buf));
+  memset (buf, 1, sizeof(buf));
   for (i = 0; i < 1024; i++)
-    pow_hash(buf, sizeof(buf), &hc);
+    pow_hash (buf, sizeof(buf), &hc);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   struct GNUNET_TIME_Absolute start;
 
-  start = GNUNET_TIME_absolute_get();
-  perfHash();
-  printf("Hash perf took %s\n",
-         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
-                                                GNUNET_YES));
-  GAUGER("NSE", "Proof-of-work hashing",
-         1024.0 / (1.0 +
-                   GNUNET_TIME_absolute_get_duration
-                     (start).rel_value_us / 1000.0), "hashes/ms");
+  start = GNUNET_TIME_absolute_get ();
+  perfHash ();
+  printf ("Hash perf took %s\n",
+          GNUNET_STRINGS_relative_time_to_string (
+            GNUNET_TIME_absolute_get_duration (start),
+            GNUNET_YES));
+  GAUGER ("NSE", "Proof-of-work hashing",
+          1024.0 / (1.0
+                    + GNUNET_TIME_absolute_get_duration
+                      (start).rel_value_us / 1000.0), "hashes/ms");
   return 0;
 }
 
diff --git a/src/nse/test_nse_api.c b/src/nse/test_nse_api.c
index b739e05a2..3b9682696 100644
--- a/src/nse/test_nse_api.c
+++ b/src/nse/test_nse_api.c
@@ -29,7 +29,7 @@
 
 static struct GNUNET_NSE_Handle *h;
 
-static struct GNUNET_SCHEDULER_Task * die_task;
+static struct GNUNET_SCHEDULER_Task *die_task;
 
 
 /**
@@ -38,13 +38,13 @@ static struct GNUNET_SCHEDULER_Task * die_task;
  * @param cls closure
  */
 static void
-end_test(void *cls)
+end_test (void *cls)
 {
   if (h != NULL)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from NSE service.\n");
-      GNUNET_NSE_disconnect(h);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from NSE service.\n");
+    GNUNET_NSE_disconnect (h);
+  }
 }
 
 /**
@@ -58,46 +58,46 @@ end_test(void *cls)
  *
  */
 static void
-check_nse_message(void *cls, struct GNUNET_TIME_Absolute timestamp,
-                  double estimate, double std_dev)
+check_nse_message (void *cls, struct GNUNET_TIME_Absolute timestamp,
+                   double estimate, double std_dev)
 {
   int *ok = cls;
 
-  fprintf(stderr,
-          "Received NSE message, estimate %f, standard deviation %f.\n",
-          estimate, std_dev);
+  fprintf (stderr,
+           "Received NSE message, estimate %f, standard deviation %f.\n",
+           estimate, std_dev);
   /* Fantastic check below. Expect NaN, the only thing not equal to itself. */
   (*ok) = 0;
   if (die_task != NULL)
-    GNUNET_SCHEDULER_cancel(die_task);
-  die_task = GNUNET_SCHEDULER_add_now(&end_test, NULL);
+    GNUNET_SCHEDULER_cancel (die_task);
+  die_task = GNUNET_SCHEDULER_add_now (&end_test, NULL);
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   die_task =
-    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
-                                   (GNUNET_TIME_UNIT_MINUTES, 1), &end_test,
-                                 NULL);
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MINUTES, 1), &end_test,
+                                  NULL);
 
-  h = GNUNET_NSE_connect(cfg, &check_nse_message, cls);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to NSE service.\n");
-  GNUNET_assert(h != NULL);
+  h = GNUNET_NSE_connect (cfg, &check_nse_message, cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to NSE service.\n");
+  GNUNET_assert (h != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   int ok = 1;
 
-  if (0 != GNUNET_TESTING_peer_run("test_nse_api",
-                                   "test_nse.conf",
-                                   &run, &ok))
+  if (0 != GNUNET_TESTING_peer_run ("test_nse_api",
+                                    "test_nse.conf",
+                                    &run, &ok))
     return 1;
   return ok;
 }
diff --git a/src/nse/test_nse_multipeer.c b/src/nse/test_nse_multipeer.c
index 88ced26d2..4c998373e 100644
--- a/src/nse/test_nse_multipeer.c
+++ b/src/nse/test_nse_multipeer.c
@@ -37,13 +37,14 @@
 /**
  * How long do we run the test?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
 
 
 /**
  * Information we track for each peer.
  */
-struct NSEPeer {
+struct NSEPeer
+{
   /**
    * Handle for NSE connect operation.
    */
@@ -71,13 +72,13 @@ static int ok;
  * Task run on timeout to shut everything down.
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   unsigned int i;
 
   for (i = 0; i < NUM_PEERS; i++)
-    GNUNET_TESTBED_operation_done(nse_peers[i].op);
-  GNUNET_SCHEDULER_shutdown();
+    GNUNET_TESTBED_operation_done (nse_peers[i].op);
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -92,17 +93,17 @@ shutdown_task(void *cls)
  *
  */
 static void
-handle_estimate(void *cls, struct GNUNET_TIME_Absolute timestamp,
-                double estimate, double std_dev)
+handle_estimate (void *cls, struct GNUNET_TIME_Absolute timestamp,
+                 double estimate, double std_dev)
 {
   struct NSEPeer *peer = cls;
 
-  fprintf(stderr,
-          "Received network size estimate from peer %u. logSize: %f std.dev. %f (%f/%u)\n",
-          (unsigned int)(peer - nse_peers),
-          estimate, std_dev,
-          GNUNET_NSE_log_estimate_to_n(estimate),
-          NUM_PEERS);
+  fprintf (stderr,
+           "Received network size estimate from peer %u. logSize: %f std.dev. %f (%f/%u)\n",
+           (unsigned int) (peer - nse_peers),
+           estimate, std_dev,
+           GNUNET_NSE_log_estimate_to_n (estimate),
+           NUM_PEERS);
   ok = 0;
 }
 
@@ -117,24 +118,24 @@ handle_estimate(void *cls, struct GNUNET_TIME_Absolute timestamp,
  *          operation has executed successfully.
  */
 static void
-nse_connect_complete_cb(void *cls,
-                        struct GNUNET_TESTBED_Operation *op,
-                        void *ca_result,
-                        const char *emsg)
+nse_connect_complete_cb (void *cls,
+                         struct GNUNET_TESTBED_Operation *op,
+                         void *ca_result,
+                         const char *emsg)
 {
   struct NSEPeer *peer = cls;
   struct GNUNET_NSE_Handle *nse = ca_result;
 
-  GNUNET_assert(op == peer->op);
+  GNUNET_assert (op == peer->op);
   if (NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Failed to connect to NSE service: %s\n",
-                 emsg);
-      ok = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to connect to NSE service: %s\n",
+                emsg);
+    ok = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   peer->nse_handle = nse;
 }
 
@@ -150,12 +151,12 @@ nse_connect_complete_cb(void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-nse_connect_adapter(void *cls,
-                    const struct GNUNET_CONFIGURATION_Handle *cfg)
+nse_connect_adapter (void *cls,
+                     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  return GNUNET_NSE_connect(cfg,
-                            &handle_estimate,
-                            cls);
+  return GNUNET_NSE_connect (cfg,
+                             &handle_estimate,
+                             cls);
 }
 
 
@@ -167,10 +168,10 @@ nse_connect_adapter(void *cls,
  * @param op_result service handle returned from the connect adapter
  */
 static void
-nse_disconnect_adapter(void *cls,
-                       void *op_result)
+nse_disconnect_adapter (void *cls,
+                        void *op_result)
 {
-  GNUNET_NSE_disconnect(op_result);
+  GNUNET_NSE_disconnect (op_result);
 }
 
 
@@ -187,27 +188,27 @@ nse_disconnect_adapter(void *cls,
  *          failed
  */
 static void
-run(void *cls,
-    struct GNUNET_TESTBED_RunHandle *h,
-    unsigned int num_peers,
-    struct GNUNET_TESTBED_Peer **peers,
-    unsigned int links_succeeded,
-    unsigned int links_failed)
+run (void *cls,
+     struct GNUNET_TESTBED_RunHandle *h,
+     unsigned int num_peers,
+     struct GNUNET_TESTBED_Peer **peers,
+     unsigned int links_succeeded,
+     unsigned int links_failed)
 {
   unsigned int i;
 
-  GNUNET_assert(NUM_PEERS == num_peers);
+  GNUNET_assert (NUM_PEERS == num_peers);
   for (i = 0; i < num_peers; i++)
-    nse_peers[i].op = GNUNET_TESTBED_service_connect(&nse_peers[i],
-                                                     peers[i],
-                                                     "nse",
-                                                     &nse_connect_complete_cb,
-                                                     &nse_peers[i],
-                                                     &nse_connect_adapter,
-                                                     &nse_disconnect_adapter,
-                                                     &nse_peers[i]);
-  GNUNET_SCHEDULER_add_delayed(TIMEOUT,
-                               &shutdown_task, NULL);
+    nse_peers[i].op = GNUNET_TESTBED_service_connect (&nse_peers[i],
+                                                      peers[i],
+                                                      "nse",
+                                                      &nse_connect_complete_cb,
+                                                      &nse_peers[i],
+                                                      &nse_connect_adapter,
+                                                      &nse_disconnect_adapter,
+                                                      &nse_peers[i]);
+  GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                &shutdown_task, NULL);
 }
 
 
@@ -219,14 +220,14 @@ run(void *cls,
  * @return 0 on success
  */
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   ok = 1;
-  (void)GNUNET_TESTBED_test_run("test-nse-multipeer",
-                                "test_nse.conf",
-                                NUM_PEERS,
-                                0, NULL, NULL,
-                                &run, NULL);
+  (void) GNUNET_TESTBED_test_run ("test-nse-multipeer",
+                                  "test_nse.conf",
+                                  NUM_PEERS,
+                                  0, NULL, NULL,
+                                  &run, NULL);
   return ok;
 }