1 files changed, 598 insertions, 600 deletions

diff --git a/src/cadet/test_cadet.c b/src/cadet/test_cadet.c
index 5a28b439e..de5e4eef0 100644
--- a/src/cadet/test_cadet.c
+++ b/src/cadet/test_cadet.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file cadet/test_cadet.c
  * @author Bart Polot
@@ -34,8 +34,7 @@
 /**
  * Ugly workaround to unify data handlers on incoming and outgoing channels.
  */
-struct CadetTestChannelWrapper
-{
+struct CadetTestChannelWrapper {
   /**
    * Channel pointer.
    */
@@ -50,17 +49,17 @@ struct CadetTestChannelWrapper
 /**
  * How long until we give up on connecting the peers?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120)
 
 /**
  * Time to wait by default  for stuff that should be rather fast.
  */
-#define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20)
+#define SHORT_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20)
 
 /**
  * How fast do we send messages?
  */
-#define SEND_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 10)
+#define SEND_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10)
 
 /**
  * DIFFERENT TESTS TO RUN
@@ -112,7 +111,7 @@ static int ok_goal;
 /**
  * Size of each test packet's payload
  */
-static size_t size_payload = sizeof (uint32_t);
+static size_t size_payload = sizeof(uint32_t);
 
 /**
  * Operation to get peer ids.
@@ -260,7 +259,7 @@ static unsigned int msg_dropped;
  *         or the last peer in the line (for other tests).
  */
 static struct GNUNET_CADET_Channel *
-get_target_channel ()
+get_target_channel()
 {
   if (SPEED == test && GNUNET_YES == test_backwards)
     return outgoing_ch;
@@ -273,29 +272,29 @@ get_target_channel ()
  * Show the results of the test (banwidth acheived) and log them to GAUGER
  */
 static void
-show_end_data (void)
+show_end_data(void)
 {
   static struct GNUNET_TIME_Absolute end_time;
   static struct GNUNET_TIME_Relative total_time;
 
-  end_time = GNUNET_TIME_absolute_get ();
-  total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time);
-  fprintf (stderr,
-           "\nResults of test \"%s\"\n",
-           test_name);
-  fprintf (stderr,
-           "Test time %s\n",
-           GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES));
-  fprintf (stderr,
-           "Test bandwidth: %f kb/s\n",
-           4 * total_packets * 1.0 / (total_time.rel_value_us / 1000));    // 4bytes * ms
-  fprintf (stderr,
-           "Test throughput: %f packets/s\n\n",
-           total_packets * 1000.0 / (total_time.rel_value_us / 1000));     // packets * ms
-  GAUGER ("CADET",
-          test_name,
-          total_packets * 1000.0 / (total_time.rel_value_us / 1000),
-          "packets/s");
+  end_time = GNUNET_TIME_absolute_get();
+  total_time = GNUNET_TIME_absolute_get_difference(start_time, end_time);
+  fprintf(stderr,
+          "\nResults of test \"%s\"\n",
+          test_name);
+  fprintf(stderr,
+          "Test time %s\n",
+          GNUNET_STRINGS_relative_time_to_string(total_time, GNUNET_YES));
+  fprintf(stderr,
+          "Test bandwidth: %f kb/s\n",
+          4 * total_packets * 1.0 / (total_time.rel_value_us / 1000));     // 4bytes * ms
+  fprintf(stderr,
+          "Test throughput: %f packets/s\n\n",
+          total_packets * 1000.0 / (total_time.rel_value_us / 1000));      // packets * ms
+  GAUGER("CADET",
+         test_name,
+         total_packets * 1000.0 / (total_time.rel_value_us / 1000),
+         "packets/s");
 }
 
 
@@ -306,30 +305,30 @@ show_end_data (void)
  * @param tc Task Context.
  */
 static void
-disconnect_cadet_peers (void *cls)
+disconnect_cadet_peers(void *cls)
 {
-  long line = (long) cls;
+  long line = (long)cls;
 
   disconnect_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "disconnecting cadet service of peers, called from line %ld\n",
-              line);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "disconnecting cadet service of peers, called from line %ld\n",
+             line);
   for (unsigned int i = 0; i < 2; i++)
-  {
-    GNUNET_TESTBED_operation_done (t_op[i]);
-  }
+    {
+      GNUNET_TESTBED_operation_done(t_op[i]);
+    }
   if (NULL != outgoing_ch)
-  {
-    GNUNET_CADET_channel_destroy (outgoing_ch);
-    outgoing_ch = NULL;
-  }
+    {
+      GNUNET_CADET_channel_destroy(outgoing_ch);
+      outgoing_ch = NULL;
+    }
   if (NULL != incoming_ch)
-  {
-    GNUNET_CADET_channel_destroy (incoming_ch);
-    incoming_ch = NULL;
-  }
-  GNUNET_CADET_TEST_cleanup (test_ctx);
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_CADET_channel_destroy(incoming_ch);
+      incoming_ch = NULL;
+    }
+  GNUNET_CADET_TEST_cleanup(test_ctx);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -340,27 +339,27 @@ disconnect_cadet_peers (void *cls)
  * @param tc Task Context.
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Ending test.\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Ending test.\n");
   if (NULL != send_next_msg_task)
-  {
-    GNUNET_SCHEDULER_cancel (send_next_msg_task);
-    send_next_msg_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(send_next_msg_task);
+      send_next_msg_task = NULL;
+    }
   if (NULL != test_task)
-  {
-    GNUNET_SCHEDULER_cancel (test_task);
-    test_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(test_task);
+      test_task = NULL;
+    }
   if (NULL != disconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-    disconnect_task =
-        GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
-                                  (void *) __LINE__);
-  }
+    {
+      GNUNET_SCHEDULER_cancel(disconnect_task);
+      disconnect_task =
+        GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers,
+                                 (void *)__LINE__);
+    }
 }
 
 
@@ -374,26 +373,26 @@ shutdown_task (void *cls)
  *          operation has executed successfully.
  */
 static void
-stats_cont (void *cls,
-            struct GNUNET_TESTBED_Operation *op,
-            const char *emsg)
+stats_cont(void *cls,
+           struct GNUNET_TESTBED_Operation *op,
+           const char *emsg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "KA sent: %u, KA received: %u\n",
-              ka_sent,
-              ka_received);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "KA sent: %u, KA received: %u\n",
+             ka_sent,
+             ka_received);
   if ((KEEPALIVE == test || REOPEN == test) &&
       ((ka_sent < 2) || (ka_sent > ka_received + 1)))
-  {
-    GNUNET_break (0);
-    ok--;
-  }
-  GNUNET_TESTBED_operation_done (stats_op);
+    {
+      GNUNET_break(0);
+      ok--;
+    }
+  GNUNET_TESTBED_operation_done(stats_op);
 
   if (NULL != disconnect_task)
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-  disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
-                                              cls);
+    GNUNET_SCHEDULER_cancel(disconnect_task);
+  disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers,
+                                             cls);
 }
 
 
@@ -409,12 +408,12 @@ stats_cont (void *cls,
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-stats_iterator (void *cls,
-                const struct GNUNET_TESTBED_Peer *peer,
-                const char *subsystem,
-                const char *name,
-                uint64_t value,
-                int is_persistent)
+stats_iterator(void *cls,
+               const struct GNUNET_TESTBED_Peer *peer,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
 {
   static const char *s_sent = "# keepalives sent";
   static const char *s_recv = "# keepalives received";
@@ -422,16 +421,16 @@ stats_iterator (void *cls,
   static const char *cdrops = "# messages dropped due to slow client";
   uint32_t i;
 
-  i = GNUNET_TESTBED_get_index (peer);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i,
-              subsystem, name, (unsigned long long) value);
-  if (0 == strncmp (s_sent, name, strlen (s_sent)) && 0 == i)
+  i = GNUNET_TESTBED_get_index(peer);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i,
+             subsystem, name, (unsigned long long)value);
+  if (0 == strncmp(s_sent, name, strlen(s_sent)) && 0 == i)
     ka_sent = value;
-  if (0 == strncmp (s_recv, name, strlen (s_recv)) && peers_requested - 1 == i)
+  if (0 == strncmp(s_recv, name, strlen(s_recv)) && peers_requested - 1 == i)
     ka_received = value;
-  if (0 == strncmp (rdrops, name, strlen (rdrops)))
+  if (0 == strncmp(rdrops, name, strlen(rdrops)))
     msg_dropped += value;
-  if (0 == strncmp (cdrops, name, strlen (cdrops)))
+  if (0 == strncmp(cdrops, name, strlen(cdrops)))
     msg_dropped += value;
 
   return GNUNET_OK;
@@ -444,26 +443,26 @@ stats_iterator (void *cls,
  * @param cls Closure (line from which the task was scheduled).
  */
 static void
-gather_stats_and_exit (void *cls)
+gather_stats_and_exit(void *cls)
 {
-  long l = (long) cls;
+  long l = (long)cls;
 
   disconnect_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "gathering statistics from line %ld\n",
-              l);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "gathering statistics from line %ld\n",
+             l);
   if (NULL != outgoing_ch)
-  {
-    GNUNET_CADET_channel_destroy (outgoing_ch);
-    outgoing_ch = NULL;
-  }
-  stats_op = GNUNET_TESTBED_get_statistics (peers_running,
-                                            testbed_peers,
-                                            "cadet",
-                                            NULL,
-                                            &stats_iterator,
-                                            stats_cont,
-                                            cls);
+    {
+      GNUNET_CADET_channel_destroy(outgoing_ch);
+      outgoing_ch = NULL;
+    }
+  stats_op = GNUNET_TESTBED_get_statistics(peers_running,
+                                           testbed_peers,
+                                           "cadet",
+                                           NULL,
+                                           &stats_iterator,
+                                           stats_cont,
+                                           cls);
 }
 
 
@@ -475,7 +474,7 @@ gather_stats_and_exit (void *cls)
  * @param channel Channel to send the message on.
  */
 static void
-send_test_message (struct GNUNET_CADET_Channel *channel);
+send_test_message(struct GNUNET_CADET_Channel *channel);
 
 /**
  * Check if payload is sane (size contains payload).
@@ -486,8 +485,8 @@ send_test_message (struct GNUNET_CADET_Channel *channel);
  *         #GNUNET_SYSERR to close it (signal serious error).
  */
 static int
-check_data (void *cls,
-            const struct GNUNET_MessageHeader *message);
+check_data(void *cls,
+           const struct GNUNET_MessageHeader *message);
 
 /**
  * Function is called whenever a message is received.
@@ -496,8 +495,8 @@ check_data (void *cls,
  * @param message the actual message
  */
 static void
-handle_data (void *cls,
-             const struct GNUNET_MessageHeader *message);
+handle_data(void *cls,
+            const struct GNUNET_MessageHeader *message);
 
 /**
  * Function called whenever an MQ-channel is destroyed, unless the destruction
@@ -511,8 +510,8 @@ handle_data (void *cls,
  * @param channel Connection to the other end (henceforth invalid).
  */
 static void
-disconnect_handler (void *cls,
-                     const struct GNUNET_CADET_Channel *channel);
+disconnect_handler(void *cls,
+                   const struct GNUNET_CADET_Channel *channel);
 
 
 /**
@@ -521,37 +520,37 @@ disconnect_handler (void *cls,
  * @param cls Closure (line from which the task was scheduled).
  */
 static void
-reconnect_op (void *cls)
+reconnect_op(void *cls)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size (data,
-                           GNUNET_MESSAGE_TYPE_DUMMY,
-                           struct GNUNET_MessageHeader,
-                           NULL),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_var_size(data,
+                          GNUNET_MESSAGE_TYPE_DUMMY,
+                          struct GNUNET_MessageHeader,
+                          NULL),
+    GNUNET_MQ_handler_end()
   };
-  long l = (long) cls;
+  long l = (long)cls;
   struct CadetTestChannelWrapper *ch;
 
   reconnect_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "reconnecting from line %ld\n",
-              l);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "reconnecting from line %ld\n",
+             l);
   if (NULL != outgoing_ch)
-  {
-    GNUNET_CADET_channel_destroy (outgoing_ch);
-    outgoing_ch = NULL;
-  }
-  ch = GNUNET_new (struct CadetTestChannelWrapper);
-  outgoing_ch = GNUNET_CADET_channel_create (h1,
-                                             ch,
-                                             p_id[1],
-                                             &port,
-                                             NULL,
-                                             &disconnect_handler,
-                                             handlers);
+    {
+      GNUNET_CADET_channel_destroy(outgoing_ch);
+      outgoing_ch = NULL;
+    }
+  ch = GNUNET_new(struct CadetTestChannelWrapper);
+  outgoing_ch = GNUNET_CADET_channel_create(h1,
+                                            ch,
+                                            p_id[1],
+                                            &port,
+                                            NULL,
+                                            &disconnect_handler,
+                                            handlers);
   ch->ch = outgoing_ch;
-  send_test_message (outgoing_ch);
+  send_test_message(outgoing_ch);
 }
 
 /**
@@ -566,47 +565,47 @@ reconnect_op (void *cls)
  * @param channel Connection to the other end (henceforth invalid).
  */
 static void
-disconnect_handler (void *cls,
-                     const struct GNUNET_CADET_Channel *channel)
+disconnect_handler(void *cls,
+                   const struct GNUNET_CADET_Channel *channel)
 {
   struct CadetTestChannelWrapper *ch_w = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Channel disconnected at %d\n",
-              ok);
-  GNUNET_assert (ch_w->ch == channel);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Channel disconnected at %d\n",
+             ok);
+  GNUNET_assert(ch_w->ch == channel);
   if (channel == incoming_ch)
-  {
-    ok++;
-    incoming_ch = NULL;
-  }
-  else if (outgoing_ch == channel)
-  {
-    if (P2P_SIGNAL == test)
     {
       ok++;
+      incoming_ch = NULL;
+    }
+  else if (outgoing_ch == channel)
+    {
+      if (P2P_SIGNAL == test)
+        {
+          ok++;
+        }
+      outgoing_ch = NULL;
     }
-    outgoing_ch = NULL;
-  }
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Unknown channel! %p\n",
-                channel);
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               "Unknown channel! %p\n",
+               channel);
   if (NULL != disconnect_task && REOPEN != test)
-  {
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-    disconnect_task =
-        GNUNET_SCHEDULER_add_now (&gather_stats_and_exit,
-                                  (void *) __LINE__);
-  }
+    {
+      GNUNET_SCHEDULER_cancel(disconnect_task);
+      disconnect_task =
+        GNUNET_SCHEDULER_add_now(&gather_stats_and_exit,
+                                 (void *)__LINE__);
+    }
   else if (NULL != reconnect_task && REOPEN == test)
-  {
-    GNUNET_SCHEDULER_cancel (reconnect_task);
-    reconnect_task =
-        GNUNET_SCHEDULER_add_now (&reconnect_op,
-                                  (void *) __LINE__);
-  }
-  GNUNET_free (ch_w);
+    {
+      GNUNET_SCHEDULER_cancel(reconnect_task);
+      reconnect_task =
+        GNUNET_SCHEDULER_add_now(&reconnect_op,
+                                 (void *)__LINE__);
+    }
+  GNUNET_free(ch_w);
 }
 
 
@@ -616,18 +615,18 @@ disconnect_handler (void *cls,
  * @param line Line in the code the abort is requested from (__LINE__).
  */
 static void
-abort_test (long line)
+abort_test(long line)
 {
   if (NULL != disconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Aborting test from %ld\n",
-                line);
-    disconnect_task =
-        GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
-                                  (void *) line);
-  }
+    {
+      GNUNET_SCHEDULER_cancel(disconnect_task);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Aborting test from %ld\n",
+                 line);
+      disconnect_task =
+        GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers,
+                                 (void *)line);
+    }
 }
 
 
@@ -639,7 +638,7 @@ abort_test (long line)
  * @param channel Channel to send the message on.
  */
 static void
-send_test_message (struct GNUNET_CADET_Channel *channel)
+send_test_message(struct GNUNET_CADET_Channel *channel)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
@@ -647,64 +646,64 @@ send_test_message (struct GNUNET_CADET_Channel *channel)
   int payload;
   int size;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending test message on channel %p\n",
-              channel);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Sending test message on channel %p\n",
+             channel);
   size = size_payload;
   if (GNUNET_NO == initialized)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n");
-    size += 1000;
-    payload = data_sent;
-    if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n");
+      size += 1000;
+      payload = data_sent;
+      if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer
         data_sent++;
-  }
+    }
   else if (SPEED == test || SPEED_ACK == test)
-  {
-    if (get_target_channel() == channel)
+    {
+      if (get_target_channel() == channel)
+        {
+          payload = ack_sent;
+          size += ack_sent;
+          ack_sent++;
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Sending ACK %u [%d bytes]\n",
+                     payload, size);
+        }
+      else
+        {
+          payload = data_sent;
+          size += data_sent;
+          data_sent++;
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Sending DATA %u [%d bytes]\n",
+                     data_sent, size);
+        }
+    }
+  else if (FORWARD == test)
     {
       payload = ack_sent;
-      size += ack_sent;
-      ack_sent++;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending ACK %u [%d bytes]\n",
-                  payload, size);
     }
-    else
+  else if (P2P_SIGNAL == test)
     {
       payload = data_sent;
-      size += data_sent;
-      data_sent++;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending DATA %u [%d bytes]\n",
-                  data_sent, size);
     }
-  }
-  else if (FORWARD == test)
-  {
-    payload = ack_sent;
-  }
-  else if (P2P_SIGNAL == test)
-  {
-    payload = data_sent;
-  }
   else if (REOPEN == test)
-  {
-    payload = data_sent;
-    data_sent++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Sending DATA %u [%d bytes]\n",
-                data_sent, size);
-  }
+    {
+      payload = data_sent;
+      data_sent++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Sending DATA %u [%d bytes]\n",
+                 data_sent, size);
+    }
   else
-  {
-    GNUNET_assert (0);
-  }
-  env = GNUNET_MQ_msg_extra (msg, size, GNUNET_MESSAGE_TYPE_DUMMY);
-
-  data = (uint32_t *) &msg[1];
-  *data = htonl (payload);
-  GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env);
+    {
+      GNUNET_assert(0);
+    }
+  env = GNUNET_MQ_msg_extra(msg, size, GNUNET_MESSAGE_TYPE_DUMMY);
+
+  data = (uint32_t *)&msg[1];
+  *data = htonl(payload);
+  GNUNET_MQ_send(GNUNET_CADET_get_mq(channel), env);
 }
 
 
@@ -715,30 +714,30 @@ send_test_message (struct GNUNET_CADET_Channel *channel)
  * @param cls Closure (unused).
  */
 static void
-send_next_msg (void *cls)
+send_next_msg(void *cls)
 {
   struct GNUNET_CADET_Channel *channel;
 
   send_next_msg_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending next message: %d\n",
-              data_sent);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Sending next message: %d\n",
+             data_sent);
 
   channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch;
-  GNUNET_assert (NULL != channel);
-  GNUNET_assert (SPEED == test);
-  send_test_message (channel);
+  GNUNET_assert(NULL != channel);
+  GNUNET_assert(SPEED == test);
+  send_test_message(channel);
   if (data_sent < total_packets)
-  {
-    /* SPEED test: Send all messages as soon as possible */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Scheduling message %d\n",
-                data_sent + 1);
-    send_next_msg_task =
-      GNUNET_SCHEDULER_add_delayed (SEND_INTERVAL,
-                                      &send_next_msg,
-                                      NULL);
-  }
+    {
+      /* SPEED test: Send all messages as soon as possible */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Scheduling message %d\n",
+                 data_sent + 1);
+      send_next_msg_task =
+        GNUNET_SCHEDULER_add_delayed(SEND_INTERVAL,
+                                     &send_next_msg,
+                                     NULL);
+    }
 }
 
 
@@ -749,20 +748,20 @@ send_next_msg (void *cls)
  * @param line Code line number to log if a timeout occurs.
  */
 static void
-reschedule_timeout_task (long line)
+reschedule_timeout_task(long line)
 {
   if ((ok % 10) == 0)
-  {
-    if (NULL != disconnect_task)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "reschedule timeout every 10 messages\n");
-      GNUNET_SCHEDULER_cancel (disconnect_task);
-      disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
-                                                      &gather_stats_and_exit,
-                                                      (void *) line);
+      if (NULL != disconnect_task)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "reschedule timeout every 10 messages\n");
+          GNUNET_SCHEDULER_cancel(disconnect_task);
+          disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+                                                         &gather_stats_and_exit,
+                                                         (void *)line);
+        }
     }
-  }
 }
 
 
@@ -775,8 +774,8 @@ reschedule_timeout_task (long line)
  *         #GNUNET_SYSERR to close it (signal serious error).
  */
 static int
-check_data (void *cls,
-            const struct GNUNET_MessageHeader *message)
+check_data(void *cls,
+           const struct GNUNET_MessageHeader *message)
 {
   return GNUNET_OK;             /* all is well-formed */
 }
@@ -789,8 +788,8 @@ check_data (void *cls,
  * @param message the actual message
  */
 static void
-handle_data (void *cls,
-             const struct GNUNET_MessageHeader *message)
+handle_data(void *cls,
+            const struct GNUNET_MessageHeader *message)
 {
   struct CadetTestChannelWrapper *ch = cls;
   struct GNUNET_CADET_Channel *channel = ch->ch;
@@ -799,101 +798,101 @@ handle_data (void *cls,
   int *counter;
 
   ok++;
-  GNUNET_CADET_receive_done (channel);
-  counter = get_target_channel () == channel ? &data_received : &ack_received;
+  GNUNET_CADET_receive_done(channel);
+  counter = get_target_channel() == channel ? &data_received : &ack_received;
 
-  reschedule_timeout_task ((long) __LINE__);
+  reschedule_timeout_task((long)__LINE__);
 
   if (channel == outgoing_ch)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Root client got a message.\n");
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Root client got a message.\n");
+    }
   else if (channel == incoming_ch)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Leaf client got a message.\n");
-  }
-  else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unknown channel %p.\n",
-                channel);
-    GNUNET_assert (0);
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              " ok: (%d/%d)\n",
-              ok,
-              ok_goal);
-  data = (uint32_t *) &message[1];
-  payload = ntohl (*data);
-  if (payload == *counter)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                " payload as expected: %u\n",
-                payload);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Leaf client got a message.\n");
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                " payload %u, expected: %u\n",
-                payload, *counter);
-  }
-
-  if (GNUNET_NO == initialized)
-  {
-    initialized = GNUNET_YES;
-    start_time = GNUNET_TIME_absolute_get ();
-    if (SPEED == test)
     {
-      GNUNET_assert (incoming_ch == channel);
-      send_next_msg_task = GNUNET_SCHEDULER_add_now (&send_next_msg,
-                                                     NULL);
-      return;
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unknown channel %p.\n",
+                 channel);
+      GNUNET_assert(0);
     }
-  }
 
-  (*counter)++;
-  if (get_target_channel () == channel) /* Got "data" */
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received);
-    if (SPEED != test || (ok_goal - 2) == ok)
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             " ok: (%d/%d)\n",
+             ok,
+             ok_goal);
+  data = (uint32_t *)&message[1];
+  payload = ntohl(*data);
+  if (payload == *counter)
     {
-      /* Send ACK */
-      send_test_message (channel);
-      return;
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 " payload as expected: %u\n",
+                 payload);
     }
-    else
+  else
     {
-      if (data_received < total_packets)
-        return;
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 " payload %u, expected: %u\n",
+                 payload, *counter);
     }
-  }
-  else /* Got "ack" */
-  {
-    if (SPEED_ACK == test || SPEED == test)
+
+  if (GNUNET_NO == initialized)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received);
-      /* Send more data */
-      send_test_message (channel);
-      if (ack_received < total_packets && SPEED != test)
-        return;
-      if (ok == 2 && SPEED == test)
-        return;
-      show_end_data ();
+      initialized = GNUNET_YES;
+      start_time = GNUNET_TIME_absolute_get();
+      if (SPEED == test)
+        {
+          GNUNET_assert(incoming_ch == channel);
+          send_next_msg_task = GNUNET_SCHEDULER_add_now(&send_next_msg,
+                                                        NULL);
+          return;
+        }
     }
-    if (test == P2P_SIGNAL)
+
+  (*counter)++;
+  if (get_target_channel() == channel)  /* Got "data" */
     {
-      GNUNET_CADET_channel_destroy (incoming_ch);
-      incoming_ch = NULL;
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received);
+      if (SPEED != test || (ok_goal - 2) == ok)
+        {
+          /* Send ACK */
+          send_test_message(channel);
+          return;
+        }
+      else
+        {
+          if (data_received < total_packets)
+            return;
+        }
     }
-    else
+  else /* Got "ack" */
     {
-      GNUNET_CADET_channel_destroy (outgoing_ch);
-      outgoing_ch = NULL;
+      if (SPEED_ACK == test || SPEED == test)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received);
+          /* Send more data */
+          send_test_message(channel);
+          if (ack_received < total_packets && SPEED != test)
+            return;
+          if (ok == 2 && SPEED == test)
+            return;
+          show_end_data();
+        }
+      if (test == P2P_SIGNAL)
+        {
+          GNUNET_CADET_channel_destroy(incoming_ch);
+          incoming_ch = NULL;
+        }
+      else
+        {
+          GNUNET_CADET_channel_destroy(outgoing_ch);
+          outgoing_ch = NULL;
+        }
     }
-  }
 }
 
 
@@ -910,66 +909,66 @@ handle_data (void *cls,
  *           received on the @a channel.
  */
 static void *
-connect_handler (void *cls,
-                 struct GNUNET_CADET_Channel *channel,
-                 const struct GNUNET_PeerIdentity *source)
+connect_handler(void *cls,
+                struct GNUNET_CADET_Channel *channel,
+                const struct GNUNET_PeerIdentity *source)
 {
   struct CadetTestChannelWrapper *ch;
-  long peer = (long) cls;
+  long peer = (long)cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Incoming channel from %s to %ld: %p\n",
-              GNUNET_i2s (source),
-              peer,
-              channel);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Incoming channel from %s to %ld: %p\n",
+             GNUNET_i2s(source),
+             peer,
+             channel);
   ok++;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              " ok: %d\n",
-              ok);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             " ok: %d\n",
+             ok);
   if (peer == peers_requested - 1)
-  {
-    if (NULL != incoming_ch)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Duplicate incoming channel for client %lu\n",
-                  (long) cls);
-      GNUNET_assert (0);
+      if (NULL != incoming_ch)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Duplicate incoming channel for client %lu\n",
+                     (long)cls);
+          GNUNET_assert(0);
+        }
+      incoming_ch = channel;
     }
-    incoming_ch = channel;
-  }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Incoming channel for unexpected peer #%lu\n",
-                (long) cls);
-    GNUNET_assert (0);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Incoming channel for unexpected peer #%lu\n",
+                 (long)cls);
+      GNUNET_assert(0);
+    }
   if (NULL != disconnect_task && REOPEN != test)
-  {
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-    disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
-                                                    &gather_stats_and_exit,
-                                                    (void *) __LINE__);
-  }
+    {
+      GNUNET_SCHEDULER_cancel(disconnect_task);
+      disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+                                                     &gather_stats_and_exit,
+                                                     (void *)__LINE__);
+    }
   else if ((NULL != disconnect_task) && (REOPEN == test))
-  {
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-    disconnect_task = GNUNET_SCHEDULER_add_delayed (
-        GNUNET_TIME_relative_multiply (short_time, 2),
+    {
+      GNUNET_SCHEDULER_cancel(disconnect_task);
+      disconnect_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(short_time, 2),
         &gather_stats_and_exit,
-        (void *) __LINE__);
-  }
+        (void *)__LINE__);
+    }
 
   if ((NULL != reconnect_task) && (REOPEN == test))
-  {
-    GNUNET_SCHEDULER_cancel (reconnect_task);
-    reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
-                                                   &reconnect_op,
-                                                   (void *) __LINE__);
-  }
+    {
+      GNUNET_SCHEDULER_cancel(reconnect_task);
+      reconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+                                                    &reconnect_op,
+                                                    (void *)__LINE__);
+    }
 
   /* TODO: cannot return channel as-is, in order to unify the data handlers */
-  ch = GNUNET_new (struct CadetTestChannelWrapper);
+  ch = GNUNET_new(struct CadetTestChannelWrapper);
   ch->ch = channel;
 
   return ch;
@@ -985,44 +984,44 @@ connect_handler (void *cls,
  * @param cls Closure (unused).
  */
 static void
-start_test (void *cls)
+start_test(void *cls)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size (data,
-                           GNUNET_MESSAGE_TYPE_DUMMY,
-                           struct GNUNET_MessageHeader,
-                           NULL),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_var_size(data,
+                          GNUNET_MESSAGE_TYPE_DUMMY,
+                          struct GNUNET_MessageHeader,
+                          NULL),
+    GNUNET_MQ_handler_end()
   };
   struct CadetTestChannelWrapper *ch;
 
   test_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "start_test: %s\n", test_name);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "start_test: %s\n", test_name);
   if (NULL != disconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-    disconnect_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(disconnect_task);
+      disconnect_task = NULL;
+    }
 
   if (SPEED_REL == test)
-  {
-    test = SPEED;
-  }
-
-  ch = GNUNET_new (struct CadetTestChannelWrapper);
-  outgoing_ch = GNUNET_CADET_channel_create (h1,
-                                             ch,
-                                             p_id[1],
-                                             &port,
-                                             NULL,
-                                             &disconnect_handler,
-                                             handlers);
+    {
+      test = SPEED;
+    }
+
+  ch = GNUNET_new(struct CadetTestChannelWrapper);
+  outgoing_ch = GNUNET_CADET_channel_create(h1,
+                                            ch,
+                                            p_id[1],
+                                            &port,
+                                            NULL,
+                                            &disconnect_handler,
+                                            handlers);
 
   ch->ch = outgoing_ch;
 
-  disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
-                                                  &gather_stats_and_exit,
-                                                  (void *) __LINE__);
+  disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+                                                 &gather_stats_and_exit,
+                                                 (void *)__LINE__);
   if (KEEPALIVE == test)
     return;                     /* Don't send any data. */
 
@@ -1030,22 +1029,21 @@ start_test (void *cls)
   data_sent = 0;
   ack_received = 0;
   ack_sent = 0;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending data initializer on channel %p...\n",
-              outgoing_ch);
-  send_test_message (outgoing_ch);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Sending data initializer on channel %p...\n",
+             outgoing_ch);
+  send_test_message(outgoing_ch);
   if (REOPEN == test)
-  {
-    reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
-                                                   &reconnect_op,
-                                                   (void *) __LINE__);
-    GNUNET_SCHEDULER_cancel (disconnect_task);
-    disconnect_task = GNUNET_SCHEDULER_add_delayed (
-        GNUNET_TIME_relative_multiply (short_time, 2),
+    {
+      reconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+                                                    &reconnect_op,
+                                                    (void *)__LINE__);
+      GNUNET_SCHEDULER_cancel(disconnect_task);
+      disconnect_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(short_time, 2),
         &gather_stats_and_exit,
-        (void *) __LINE__);
-  }
-
+        (void *)__LINE__);
+    }
 }
 
 
@@ -1059,35 +1057,35 @@ start_test (void *cls)
  *             NULL if the operation is successfull
  */
 static void
-pi_cb (void *cls,
-       struct GNUNET_TESTBED_Operation *op,
-       const struct GNUNET_TESTBED_PeerInformation *pinfo,
-       const char *emsg)
+pi_cb(void *cls,
+      struct GNUNET_TESTBED_Operation *op,
+      const struct GNUNET_TESTBED_PeerInformation *pinfo,
+      const char *emsg)
 {
-  long i = (long) cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "ID callback for %ld\n",
-              i);
-  if ( (NULL == pinfo) ||
-       (NULL != emsg) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "pi_cb: %s\n",
-                emsg);
-    abort_test (__LINE__);
-    return;
-  }
+  long i = (long)cls;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "ID callback for %ld\n",
+             i);
+  if ((NULL == pinfo) ||
+      (NULL != emsg))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "pi_cb: %s\n",
+                 emsg);
+      abort_test(__LINE__);
+      return;
+    }
   p_id[i] = pinfo->result.id;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "id: %s\n",
-              GNUNET_i2s (p_id[i]));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "id: %s\n",
+             GNUNET_i2s(p_id[i]));
   p_ids++;
   if (p_ids < 2)
     return;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got all IDs, starting test\n");
-  test_task = GNUNET_SCHEDULER_add_now (&start_test, NULL);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got all IDs, starting test\n");
+  test_task = GNUNET_SCHEDULER_add_now(&start_test, NULL);
 }
 
 
@@ -1101,34 +1099,34 @@ pi_cb (void *cls,
  * @param cadets Handle to each of the CADETs of the peers.
  */
 static void
-tmain (void *cls,
-       struct GNUNET_CADET_TEST_Context *ctx,
-       unsigned int num_peers,
-       struct GNUNET_TESTBED_Peer **peers,
-       struct GNUNET_CADET_Handle **cadets)
+tmain(void *cls,
+      struct GNUNET_CADET_TEST_Context *ctx,
+      unsigned int num_peers,
+      struct GNUNET_TESTBED_Peer **peers,
+      struct GNUNET_CADET_Handle **cadets)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test main\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "test main\n");
   ok = 0;
   test_ctx = ctx;
   peers_running = num_peers;
-  GNUNET_assert (peers_running == peers_requested);
+  GNUNET_assert(peers_running == peers_requested);
   testbed_peers = peers;
   h1 = cadets[0];
   h2 = cadets[num_peers - 1];
-  disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
-                                                  &disconnect_cadet_peers,
-                                                  (void *) __LINE__);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 NULL);
-  t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0],
-                                                 GNUNET_TESTBED_PIT_IDENTITY,
-                                                 &pi_cb,
-                                                 (void *) 0L);
-  t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1],
-                                                 GNUNET_TESTBED_PIT_IDENTITY,
-                                                 &pi_cb,
-                                                 (void *) 1L);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n");
+  disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+                                                 &disconnect_cadet_peers,
+                                                 (void *)__LINE__);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
+                                NULL);
+  t_op[0] = GNUNET_TESTBED_peer_get_information(peers[0],
+                                                GNUNET_TESTBED_PIT_IDENTITY,
+                                                &pi_cb,
+                                                (void *)0L);
+  t_op[1] = GNUNET_TESTBED_peer_get_information(peers[num_peers - 1],
+                                                GNUNET_TESTBED_PIT_IDENTITY,
+                                                &pi_cb,
+                                                (void *)1L);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n");
 }
 
 
@@ -1136,179 +1134,179 @@ tmain (void *cls,
  * Main: start test
  */
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   static const struct GNUNET_HashCode *ports[2];
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size (data,
-                           GNUNET_MESSAGE_TYPE_DUMMY,
-                           struct GNUNET_MessageHeader,
-                           NULL),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_var_size(data,
+                          GNUNET_MESSAGE_TYPE_DUMMY,
+                          struct GNUNET_MessageHeader,
+                          NULL),
+    GNUNET_MQ_handler_end()
   };
   const char *config_file;
   char port_id[] = "test port";
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_relative_time ('t',
-                                        "time",
-                                        "short_time",
-                                        gettext_noop ("set short timeout"),
-                                        &short_time),
-    GNUNET_GETOPT_option_uint ('m',
-                               "messages",
-                               "NUM_MESSAGES",
-                               gettext_noop ("set number of messages to send"),
-                               &total_packets),
+    GNUNET_GETOPT_option_relative_time('t',
+                                       "time",
+                                       "short_time",
+                                       gettext_noop("set short timeout"),
+                                       &short_time),
+    GNUNET_GETOPT_option_uint('m',
+                              "messages",
+                              "NUM_MESSAGES",
+                              gettext_noop("set number of messages to send"),
+                              &total_packets),
 
     GNUNET_GETOPT_OPTION_END
   };
 
 
   initialized = GNUNET_NO;
-  GNUNET_log_setup ("test", "DEBUG", NULL);
+  GNUNET_log_setup("test", "DEBUG", NULL);
 
   total_packets = TOTAL_PACKETS;
   short_time = SHORT_TIME;
-  if (-1 == GNUNET_GETOPT_run (argv[0], options, argc, argv))
-  {
-    fprintf (stderr, "test failed: problem with CLI parameters\n");
-    exit (1);
-  }
+  if (-1 == GNUNET_GETOPT_run(argv[0], options, argc, argv))
+    {
+      fprintf(stderr, "test failed: problem with CLI parameters\n");
+      exit(1);
+    }
 
   config_file = "test_cadet.conf";
-  GNUNET_CRYPTO_hash (port_id, sizeof (port_id), &port);
+  GNUNET_CRYPTO_hash(port_id, sizeof(port_id), &port);
 
   /* Find out requested size */
-  if (strstr (argv[0], "_2_") != NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n");
-    peers_requested = 2;
-  }
-  else if (strstr (argv[0], "_5_") != NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n");
-    peers_requested = 5;
-  }
-  else if (strstr (argv[0], "_6_") != NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "6 PEER LINE\n");
-    peers_requested = 6;
-  }
+  if (strstr(argv[0], "_2_") != NULL)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n");
+      peers_requested = 2;
+    }
+  else if (strstr(argv[0], "_5_") != NULL)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n");
+      peers_requested = 5;
+    }
+  else if (strstr(argv[0], "_6_") != NULL)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "6 PEER LINE\n");
+      peers_requested = 6;
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n");
-    peers_requested = 2;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n");
+      peers_requested = 2;
+    }
 
   /* Find out requested test */
-  if (strstr (argv[0], "_forward") != NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n");
-    test = FORWARD;
-    test_name = "unicast";
-    ok_goal = 4;
-  }
-  else if (strstr (argv[0], "_signal") != NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n");
-    test = P2P_SIGNAL;
-    test_name = "signal";
-    ok_goal = 4;
-  }
-  else if (strstr (argv[0], "_speed_ack") != NULL)
-  {
-    /* Test is supposed to generate the following callbacks:
-     * 1 incoming channel (@dest)
-     * total_packets received data packet (@dest)
-     * total_packets received data packet (@orig)
-     * 1 received channel destroy (@dest) FIXME #5818
-     */
-    ok_goal = total_packets * 2 + 2;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n");
-    test = SPEED_ACK;
-    test_name = "speed ack";
-  }
-  else if (strstr (argv[0], "_speed") != NULL)
-  {
-    /* Test is supposed to generate the following callbacks:
-     * 1 incoming channel (@dest)
-     * 1 initial packet (@dest)
-     * total_packets received data packet (@dest)
-     * 1 received data packet (@orig)
-     * 1 received channel destroy (@dest)  FIXME #5818
-     */
-    ok_goal = total_packets + 4;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED\n");
-    if (strstr (argv[0], "_reliable") != NULL)
+  if (strstr(argv[0], "_forward") != NULL)
     {
-      test = SPEED_REL;
-      test_name = "speed reliable";
-      config_file = "test_cadet_drop.conf";
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n");
+      test = FORWARD;
+      test_name = "unicast";
+      ok_goal = 4;
     }
-    else
+  else if (strstr(argv[0], "_signal") != NULL)
     {
-      test = SPEED;
-      test_name = "speed";
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n");
+      test = P2P_SIGNAL;
+      test_name = "signal";
+      ok_goal = 4;
+    }
+  else if (strstr(argv[0], "_speed_ack") != NULL)
+    {
+      /* Test is supposed to generate the following callbacks:
+       * 1 incoming channel (@dest)
+       * total_packets received data packet (@dest)
+       * total_packets received data packet (@orig)
+       * 1 received channel destroy (@dest) FIXME #5818
+       */
+      ok_goal = total_packets * 2 + 2;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n");
+      test = SPEED_ACK;
+      test_name = "speed ack";
+    }
+  else if (strstr(argv[0], "_speed") != NULL)
+    {
+      /* Test is supposed to generate the following callbacks:
+       * 1 incoming channel (@dest)
+       * 1 initial packet (@dest)
+       * total_packets received data packet (@dest)
+       * 1 received data packet (@orig)
+       * 1 received channel destroy (@dest)  FIXME #5818
+       */
+      ok_goal = total_packets + 4;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SPEED\n");
+      if (strstr(argv[0], "_reliable") != NULL)
+        {
+          test = SPEED_REL;
+          test_name = "speed reliable";
+          config_file = "test_cadet_drop.conf";
+        }
+      else
+        {
+          test = SPEED;
+          test_name = "speed";
+        }
+    }
+  else if (strstr(argv[0], "_keepalive") != NULL)
+    {
+      test = KEEPALIVE;
+      test_name = "keepalive";
+      /* Test is supposed to generate the following callbacks:
+       * 1 incoming channel (@dest)
+       * [wait]
+       * 1 received channel destroy (@dest)  FIXME #5818
+       */
+      ok_goal = 1;
+    }
+  else if (strstr(argv[0], "_reopen") != NULL)
+    {
+      test = REOPEN;
+      test_name = "reopen";
+      ///* Test is supposed to generate the following callbacks:
+      // * 1 incoming channel (@dest)
+      // * [wait]
+      // * 1 received channel destroy (@dest)  FIXME #5818
+      // */
+      ok_goal = 6;
     }
-  }
-  else if (strstr (argv[0], "_keepalive") != NULL)
-  {
-    test = KEEPALIVE;
-    test_name = "keepalive";
-    /* Test is supposed to generate the following callbacks:
-     * 1 incoming channel (@dest)
-     * [wait]
-     * 1 received channel destroy (@dest)  FIXME #5818
-     */
-    ok_goal = 1;
-  }
-  else if (strstr (argv[0], "_reopen") != NULL)
-  {
-    test = REOPEN;
-    test_name = "reopen";
-    ///* Test is supposed to generate the following callbacks:
-    // * 1 incoming channel (@dest)
-    // * [wait]
-    // * 1 received channel destroy (@dest)  FIXME #5818
-    // */
-    ok_goal = 6;
-  }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n");
-    test = SETUP;
-    ok_goal = 0;
-  }
-
-  if (strstr (argv[0], "backwards") != NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n");
-    test_backwards = GNUNET_YES;
-    GNUNET_asprintf (&test_name, "backwards %s", test_name);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n");
+      test = SETUP;
+      ok_goal = 0;
+    }
+
+  if (strstr(argv[0], "backwards") != NULL)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n");
+      test_backwards = GNUNET_YES;
+      GNUNET_asprintf(&test_name, "backwards %s", test_name);
+    }
 
   p_ids = 0;
   ports[0] = &port;
   ports[1] = NULL;
-  GNUNET_CADET_TEST_ruN ("test_cadet_small",
-                         config_file,
-                         peers_requested,
-                         &tmain,
-                         NULL,        /* tmain cls */
-                         &connect_handler,
-                         NULL,
-                         &disconnect_handler,
-                         handlers,
-                         ports);
-  if (NULL != strstr (argv[0], "_reliable"))
+  GNUNET_CADET_TEST_ruN("test_cadet_small",
+                        config_file,
+                        peers_requested,
+                        &tmain,
+                        NULL,         /* tmain cls */
+                        &connect_handler,
+                        NULL,
+                        &disconnect_handler,
+                        handlers,
+                        ports);
+  if (NULL != strstr(argv[0], "_reliable"))
     msg_dropped = 0;            /* dropped should be retransmitted */
 
   if (ok_goal > ok - msg_dropped)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal);
-    return 1;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "success\n");
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal);
+      return 1;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "success\n");
   return 0;
 }