3 files changed, 175 insertions, 154 deletions

diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c
index db2aea552..e2f1e4507 100644
--- a/src/transport/gnunet-communicator-tcp.c
+++ b/src/transport/gnunet-communicator-tcp.c
@@ -1513,13 +1513,13 @@ handshake_ack_monotime_cb (void *cls,
  */
 static void
 send_challenge (struct GNUNET_CRYPTO_ChallengeNonceP challenge,
-                struct Queue *queue)
+                struct Queue *queue)
 {
   struct TCPConfirmationAck tca;
   struct TcpHandshakeAckSignature thas;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "sending challenge\n");
+              "sending challenge\n");
 
   tca.header.type = ntohs (
     GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK);
@@ -1546,7 +1546,7 @@ send_challenge (struct GNUNET_CRYPTO_ChallengeNonceP challenge,
                                       sizeof(tca)));
   queue->cwrite_off += sizeof(tca);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-               "sending challenge done\n");
+              "sending challenge done\n");
 }
 
 
@@ -1632,8 +1632,8 @@ inject_rekey (struct Queue *queue)
 
 static int
 pending_reversals_delete_it (void *cls,
-                  const struct GNUNET_HashCode *key,
-                  void *value)
+                             const struct GNUNET_HashCode *key,
+                             void *value)
 {
   (void) cls;
   struct PendingReversal *pending_reversal = value;
@@ -1643,9 +1643,10 @@ pending_reversals_delete_it (void *cls,
     GNUNET_SCHEDULER_cancel (pending_reversal->timeout_task);
     pending_reversal->timeout_task = NULL;
   }
-  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (pending_reversals,
-                                                         key,
-                                                         pending_reversal));
+  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (
+                   pending_reversals,
+                   key,
+                   pending_reversal));
   GNUNET_free (pending_reversal->in);
   GNUNET_free (pending_reversal);
   return GNUNET_OK;
@@ -1653,33 +1654,37 @@ pending_reversals_delete_it (void *cls,
 
 
 static void
-check_and_remove_pending_reversal (struct sockaddr *in, sa_family_t sa_family, struct GNUNET_PeerIdentity *sender)
+check_and_remove_pending_reversal (struct sockaddr *in, sa_family_t sa_family,
+                                   struct GNUNET_PeerIdentity *sender)
 {
   if (AF_INET == sa_family)
-      {
-        struct PendingReversal *pending_reversal;
-        struct GNUNET_HashCode key;
-        struct sockaddr_in *natted_address;
-
-        natted_address = GNUNET_memdup (in, sizeof (struct sockaddr));
-        natted_address->sin_port = 0;
-        GNUNET_CRYPTO_hash (natted_address,
-                            sizeof(struct sockaddr),
-                            &key);
-
-        pending_reversal = GNUNET_CONTAINER_multihashmap_get (pending_reversals,
-                                                              &key);
-        if (NULL != pending_reversal && (NULL == sender ||
-                                         0 != memcmp (sender, &pending_reversal->target, sizeof(struct GNUNET_PeerIdentity))))
-        {
-            GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                        "Removing invalid pending reversal for `%s'at `%s'\n",
-                        GNUNET_i2s (&pending_reversal->target),
-                        GNUNET_a2s (in, sizeof (struct sockaddr)));
-                        pending_reversals_delete_it (NULL, &key, pending_reversal);
-        }
-        GNUNET_free (natted_address);
-      }
+  {
+    struct PendingReversal *pending_reversal;
+    struct GNUNET_HashCode key;
+    struct sockaddr_in *natted_address;
+
+    natted_address = GNUNET_memdup (in, sizeof (struct sockaddr));
+    natted_address->sin_port = 0;
+    GNUNET_CRYPTO_hash (natted_address,
+                        sizeof(struct sockaddr),
+                        &key);
+
+    pending_reversal = GNUNET_CONTAINER_multihashmap_get (pending_reversals,
+                                                          &key);
+    if (NULL != pending_reversal && (NULL == sender ||
+                                     0 != memcmp (sender,
+                                                  &pending_reversal->target,
+                                                  sizeof(struct
+                                                         GNUNET_PeerIdentity))))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Removing invalid pending reversal for `%s'at `%s'\n",
+                  GNUNET_i2s (&pending_reversal->target),
+                  GNUNET_a2s (in, sizeof (struct sockaddr)));
+      pending_reversals_delete_it (NULL, &key, pending_reversal);
+    }
+    GNUNET_free (natted_address);
+  }
 }
 
 
@@ -1971,7 +1976,8 @@ try_handle_plaintext (struct Queue *queue)
     }
     else if (GNUNET_TRANSPORT_CS_OUTBOUND ==     queue->cs)
     {
-      check_and_remove_pending_reversal (queue->address, queue->address->sa_family, NULL);
+      check_and_remove_pending_reversal (queue->address,
+                                         queue->address->sa_family, NULL);
     }
 
     unverified_size = -1;
@@ -2691,7 +2697,7 @@ transmit_kx (struct Queue *queue,
   queue->cwrite_off += sizeof(tc);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "handshake written\n");
+              "handshake written\n");
 }
 
 
@@ -2987,7 +2993,8 @@ proto_read_kx (void *cls)
   {
     struct TCPNATProbeMessage *pm = (struct TCPNATProbeMessage *) pq->ibuf;
 
-    check_and_remove_pending_reversal (pq->address, pq->address->sa_family, &pm->clientIdentity);
+    check_and_remove_pending_reversal (pq->address, pq->address->sa_family,
+                                       &pm->clientIdentity);
 
     queue = GNUNET_new (struct Queue);
     queue->target = pm->clientIdentity;
@@ -3009,13 +3016,13 @@ proto_read_kx (void *cls)
                      queue);
     if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, pq->ibuf))
     {
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                    "Invalid TCP KX received from %s\n",
-                    GNUNET_a2s (pq->address, pq->address_len));
-        gcry_cipher_close (queue->in_cipher);
-        GNUNET_free (queue);
-        free_proto_queue (pq);
-        return;
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Invalid TCP KX received from %s\n",
+                  GNUNET_a2s (pq->address, pq->address_len));
+      gcry_cipher_close (queue->in_cipher);
+      GNUNET_free (queue);
+      free_proto_queue (pq);
+      return;
     }
     queue->target = tc.sender;
     queue->cs = GNUNET_TRANSPORT_CS_INBOUND;
@@ -3062,29 +3069,29 @@ create_proto_queue (struct GNUNET_NETWORK_Handle *sock,
 
   if (NULL == sock)
   {
-    //sock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, addr, addrlen);
+    // sock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, addr, addrlen);
     sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, 0);
     if (NULL == sock)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    "socket(%d) failed: %s",
-                    in->sa_family,
-                    strerror (errno));
-        GNUNET_free (in);
-        GNUNET_free (pq);
-        return NULL;
-      }
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "socket(%d) failed: %s",
+                  in->sa_family,
+                  strerror (errno));
+      GNUNET_free (in);
+      GNUNET_free (pq);
+      return NULL;
+    }
     if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (sock, in, addrlen)) &&
         (errno != EINPROGRESS))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    "connect to `%s' failed: %s",
-                    GNUNET_a2s (in, addrlen),
-                    strerror (errno));
-        GNUNET_NETWORK_socket_close (sock);
-        GNUNET_free (in);
-        return NULL;
-      }
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "connect to `%s' failed: %s",
+                  GNUNET_a2s (in, addrlen),
+                  strerror (errno));
+      GNUNET_NETWORK_socket_close (sock);
+      GNUNET_free (in);
+      return NULL;
+    }
   }
   pq->address_len = addrlen;
   pq->address = in;
@@ -3158,31 +3165,31 @@ try_connection_reversal (void *cls,
   struct sockaddr *in_addr;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "addr->sa_family %d\n",
-                    addr->sa_family);
+              "addr->sa_family %d\n",
+              addr->sa_family);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Try to connect back\n");
   in_addr = GNUNET_memdup (addr, addrlen);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "in_addr->sa_family %d\n",
-                    in_addr->sa_family);
+              "in_addr->sa_family %d\n",
+              in_addr->sa_family);
   pq = create_proto_queue (NULL, in_addr, addrlen);
   if (NULL != pq)
   {
-      pm.header.size = htons (sizeof(struct TCPNATProbeMessage));
-      pm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE);
-      pm.clientIdentity = my_identity;
-      memcpy (pq->write_buf, &pm, sizeof(struct TCPNATProbeMessage));
-      pq->write_off = sizeof(struct TCPNATProbeMessage);
-      pq->write_task = GNUNET_SCHEDULER_add_write_net (PROTO_QUEUE_TIMEOUT,
-                                                       pq->sock,
-                                                       &proto_queue_write,
-                                                       pq);
+    pm.header.size = htons (sizeof(struct TCPNATProbeMessage));
+    pm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE);
+    pm.clientIdentity = my_identity;
+    memcpy (pq->write_buf, &pm, sizeof(struct TCPNATProbeMessage));
+    pq->write_off = sizeof(struct TCPNATProbeMessage);
+    pq->write_task = GNUNET_SCHEDULER_add_write_net (PROTO_QUEUE_TIMEOUT,
+                                                     pq->sock,
+                                                     &proto_queue_write,
+                                                     pq);
   }
   else
   {
-     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "Couldn't create ProtoQueue for sending TCPNATProbeMessage\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Couldn't create ProtoQueue for sending TCPNATProbeMessage\n");
   }
 }
 
@@ -3268,43 +3275,45 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
               GNUNET_a2s (in, in_len));
 
   switch (in->sa_family)
+  {
+  case AF_INET:
+    v4 = (struct sockaddr_in *) in;
+    if (0 == v4->sin_port)
     {
-    case AF_INET:
-      v4 = (struct sockaddr_in *) in;
-      if (0 == v4->sin_port){
-        is_natd = GNUNET_YES;
-        GNUNET_CRYPTO_hash (in,
-                      sizeof(struct sockaddr),
-                      &key);
-        if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (pending_reversals,
-                                                                   &key))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "There is already a request reversal for `%s'at `%s'\n",
-                      GNUNET_i2s (peer),
-                      address);
-          GNUNET_free (in);
-          return GNUNET_SYSERR;
-        }
-      }
-      break;
-
-    case AF_INET6:
-      v6 = (struct sockaddr_in6 *) in;
-      if (0 == v6->sin6_port)
+      is_natd = GNUNET_YES;
+      GNUNET_CRYPTO_hash (in,
+                          sizeof(struct sockaddr),
+                          &key);
+      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (
+            pending_reversals,
+            &key))
       {
         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "Request reversal for `%s' at `%s' not possible for an IPv6 address\n",
-                      GNUNET_i2s (peer),
-                      address);
+                    "There is already a request reversal for `%s'at `%s'\n",
+                    GNUNET_i2s (peer),
+                    address);
         GNUNET_free (in);
         return GNUNET_SYSERR;
       }
-      break;
+    }
+    break;
 
-    default:
-      GNUNET_assert (0);
+  case AF_INET6:
+    v6 = (struct sockaddr_in6 *) in;
+    if (0 == v6->sin6_port)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Request reversal for `%s' at `%s' not possible for an IPv6 address\n",
+                  GNUNET_i2s (peer),
+                  address);
+      GNUNET_free (in);
+      return GNUNET_SYSERR;
     }
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
 
   if (GNUNET_YES == is_natd)
   {
@@ -3320,9 +3329,9 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
     if (GNUNET_OK != GNUNET_NAT_request_reversal (nat, &local_sa, v4))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "request reversal for `%s' at `%s' failed\n",
-                      GNUNET_i2s (peer),
-                      address);
+                  "request reversal for `%s' at `%s' failed\n",
+                  GNUNET_i2s (peer),
+                  address);
       GNUNET_free (in);
       return GNUNET_SYSERR;
     }
@@ -3334,18 +3343,22 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
                                                       pending_reversal,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
     pending_reversal->target = *peer;
-    pending_reversal->timeout_task = GNUNET_SCHEDULER_add_delayed (NAT_TIMEOUT, &pending_reversal_timeout, in);
+    pending_reversal->timeout_task = GNUNET_SCHEDULER_add_delayed (NAT_TIMEOUT,
+                                                                   &
+                                                                   pending_reversal_timeout,
+                                                                   in);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-         "Created NAT WAIT connection to `%s' at `%s'\n",
-         GNUNET_i2s (peer),
-         GNUNET_a2s (in, sizeof (struct sockaddr)));
+                "Created NAT WAIT connection to `%s' at `%s'\n",
+                GNUNET_i2s (peer),
+                GNUNET_a2s (in, sizeof (struct sockaddr)));
   }
   else
   {
     struct GNUNET_NETWORK_Handle *sock;
     struct Queue *queue;
 
-    sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP);
+    sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM,
+                                         IPPROTO_TCP);
     if (NULL == sock)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
@@ -3478,7 +3491,8 @@ do_shutdown (void *cls)
     GNUNET_NAT_unregister (nat);
     nat = NULL;
   }
-  GNUNET_CONTAINER_multihashmap_iterate (pending_reversals, &pending_reversals_delete_it, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (pending_reversals,
+                                         &pending_reversals_delete_it, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (pending_reversals);
   GNUNET_CONTAINER_multihashmap_iterate (lt_map, &get_lt_delete_it, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (lt_map);
@@ -4040,7 +4054,7 @@ main (int argc, char *const *argv)
   int ret;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                           "Starting tcp communicator\n");
+              "Starting tcp communicator\n");
   if (GNUNET_OK !=
       GNUNET_STRINGS_get_utf8_args (argc, argv,
                                     &argc, &argv))
diff --git a/src/transport/test_transport_plugin_cmd_simple_send_performance.c b/src/transport/test_transport_plugin_cmd_simple_send_performance.c
index 9cd780705..2251f9849 100644
--- a/src/transport/test_transport_plugin_cmd_simple_send_performance.c
+++ b/src/transport/test_transport_plugin_cmd_simple_send_performance.c
@@ -86,7 +86,8 @@ struct Sender
  */
 static int
 check_test (void *cls,
-            const struct GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *message)
+            const struct
+            GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *message)
 {
   return GNUNET_OK;
 }
@@ -99,7 +100,8 @@ check_test (void *cls,
  */
 static void
 handle_test (void *cls,
-             const struct GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *message)
+             const struct
+             GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *message)
 {
   struct GNUNET_PeerIdentity *peer = cls;
   const struct GNUNET_TESTING_AsyncContext *ac;
@@ -131,11 +133,13 @@ handle_test (void *cls,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "time traveled init %s\n",
-                GNUNET_i2s(peer));
+                GNUNET_i2s (peer));
     sender = GNUNET_new (struct Sender);
     sender->time_first = time_send;
     sender->mean_time = GNUNET_TIME_UNIT_ZERO;
-    GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (senders, peer, sender, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (senders,
+                                                                   peer, sender,
+                                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   }
 
   if (GNUNET_TIME_UNIT_ZERO.rel_value_us == sender->mean_time.rel_value_us)
@@ -146,7 +150,8 @@ handle_test (void *cls,
   }
   else
   {
-    double factor = (double) sender->num_received/((double) sender->num_received + 1.0);
+    double factor = (double) sender->num_received
+                    / ((double) sender->num_received + 1.0);
     struct GNUNET_TIME_Relative s1;
     struct GNUNET_TIME_Relative s2;
 
@@ -188,7 +193,7 @@ handle_test (void *cls,
 struct GNUNET_TESTING_BarrierList*
 get_waiting_for_barriers ()
 {
-  struct GNUNET_TESTING_BarrierList* barriers;
+  struct GNUNET_TESTING_BarrierList*barriers;
   struct GNUNET_TESTING_BarrierListEntry *ble;
 
   barriers = GNUNET_new (struct GNUNET_TESTING_BarrierList);
@@ -307,7 +312,7 @@ all_local_tests_prepared ()
  *        the topology configuration.
  * @param read_file If read_file is GNUNET_YES this string is the filename for the topology configuration,
  *        if read_file is GNUNET_NO the string contains the topology configuration.
- * @param finish_cb Callback function which writes a message from the helper process running on a netjail 
+ * @param finish_cb Callback function which writes a message from the helper process running on a netjail
  *                  node to the master process * signaling that the test case running on the netjail node finished.
  * @return Returns the struct GNUNET_TESTING_Interpreter of the command loop running on this netjail node.
  */
@@ -411,19 +416,20 @@ start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
   struct GNUNET_MQ_MessageHandler handlers[] = {
     GNUNET_MQ_hd_var_size (test,
                            GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE,
-                           struct GNUNET_TRANSPORT_TESTING_PerformanceTestMessage,
+                           struct
+                           GNUNET_TRANSPORT_TESTING_PerformanceTestMessage,
                            ts),
     GNUNET_MQ_handler_end ()
   };
 
   start_peer = GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
-                                   "system-create",
-                                   num,
-                                   node_ip,
-                                   handlers,
-                                   ts->cfgname,
-                                   notify_connect,
-                                   GNUNET_NO);
+                                                "system-create",
+                                                num,
+                                                node_ip,
+                                                handlers,
+                                                ts->cfgname,
+                                                notify_connect,
+                                                GNUNET_NO);
 
   struct GNUNET_TESTING_Command commands[] = {
     GNUNET_TESTING_cmd_system_create ("system-create",
@@ -437,12 +443,12 @@ start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
                                         write_message),
     connect_peers,
     GNUNET_TRANSPORT_cmd_send_simple_performance ("send-simple",
-                                      "start-peer",
-                                      "system-create",
-                                      num,
-                                      MESSAGE_SIZE,
-                                      MAX_RECEIVED,
-                                      topology),
+                                                  "start-peer",
+                                                  "system-create",
+                                                  num,
+                                                  MESSAGE_SIZE,
+                                                  MAX_RECEIVED,
+                                                  topology),
     block_receive,
     GNUNET_TESTING_cmd_barrier_reached ("test-case-finished-reached",
                                         "test-case-finished",
@@ -460,9 +466,9 @@ start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
   ts->write_message = write_message;
 
   is = GNUNET_TESTING_run (commands,
-                      TIMEOUT,
-                      &handle_result,
-                      ts);
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
   return is;
 }
 
diff --git a/src/transport/transport_api_cmd_send_simple_performance.c b/src/transport/transport_api_cmd_send_simple_performance.c
index d7850e007..5fe8d4de8 100644
--- a/src/transport/transport_api_cmd_send_simple_performance.c
+++ b/src/transport/transport_api_cmd_send_simple_performance.c
@@ -80,7 +80,7 @@ struct MQWrapper
    * State of the command.
    */
   struct SendSimplePerfState *sss;
-  
+
   /**
    * Message queue for a peer.
    */
@@ -169,7 +169,7 @@ send_simple_run (void *cls,
   const struct GNUNET_TESTING_Command *peer1_cmd;
   const struct GNUNET_TESTING_Command *system_cmd;
   const struct GNUNET_TESTING_System *tl_system;
-  
+
 
   peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
                                                          sss->start_peer_label);
@@ -190,13 +190,14 @@ send_simple_run (void *cls,
 
 struct GNUNET_TESTING_Command
 GNUNET_TRANSPORT_cmd_send_simple_performance (const char *label,
-                                  const char *start_peer_label,
-                                  const char *create_label,
-                                  uint32_t num,
-                                  int size,
-                                  int max_send,
-                                  struct GNUNET_TESTING_NetjailTopology *
-                                  topology)
+                                              const char *start_peer_label,
+                                              const char *create_label,
+                                              uint32_t num,
+                                              int size,
+                                              int max_send,
+                                              struct
+                                              GNUNET_TESTING_NetjailTopology *
+                                              topology)
 {
   struct SendSimplePerfState *sss;
   struct GNUNET_TESTING_Command cmd;
@@ -209,11 +210,11 @@ GNUNET_TRANSPORT_cmd_send_simple_performance (const char *label,
   sss->max_send = max_send;
 
   cmd = GNUNET_TESTING_command_new (sss,
-                                     label,
-                                     &send_simple_run,
-                                     &send_simple_cleanup,
-                                     NULL,
-                                     &sss->ac);
+                                    label,
+                                    &send_simple_run,
+                                    &send_simple_cleanup,
+                                    NULL,
+                                    &sss->ac);
   cmd.asynchronous_finish = GNUNET_YES;
   return cmd;
 }