61 files changed, 16303 insertions, 16906 deletions

diff --git a/src/transport/gnunet-service-transport-new.c b/src/transport/gnunet-service-transport-new.c
index 3cc1191fd..8ceffd86c 100644
--- a/src/transport/gnunet-service-transport-new.c
+++ b/src/transport/gnunet-service-transport-new.c
@@ -86,17 +86,16 @@ struct GNUNET_ATS_Handle *GST_ats;
  */
 static void
 transmit_our_hello (void *cls,
-                    const struct GNUNET_PeerIdentity *target,
-                    const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-                    uint32_t ats_count)
+                    const struct GNUNET_PeerIdentity *target,
+                    const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                    uint32_t ats_count)
 {
   const struct GNUNET_MessageHeader *hello = cls;
 
   GST_neighbours_send (target,
-                       (const char*) hello,
-                       ntohs (hello->size),
-                       GST_HELLO_ADDRESS_EXPIRATION,
-                       NULL, NULL);
+                       (const char *) hello,
+                       ntohs (hello->size),
+                       GST_HELLO_ADDRESS_EXPIRATION, NULL, NULL);
 }
 
 
@@ -107,12 +106,10 @@ transmit_our_hello (void *cls,
  * @param hello new HELLO
  */
 static void
-process_hello_update (void *cls,
-                      const struct GNUNET_MessageHeader *hello)
+process_hello_update (void *cls, const struct GNUNET_MessageHeader *hello)
 {
   GST_clients_broadcast (hello, GNUNET_NO);
-  GST_neighbours_iterate (&transmit_our_hello,
-                          (void*) hello);
+  GST_neighbours_iterate (&transmit_our_hello, (void *) hello);
 }
 
 
@@ -127,11 +124,10 @@ process_hello_update (void *cls,
  */
 static void
 try_connect_if_allowed (void *cls,
-                        const struct GNUNET_PeerIdentity *peer,
-                        int result)
+                        const struct GNUNET_PeerIdentity *peer, int result)
 {
   if (GNUNET_OK != result)
-    return; /* not allowed */
+    return;                     /* not allowed */
   GST_neighbours_try_connect (peer);
 }
 
@@ -159,14 +155,14 @@ try_connect_if_allowed (void *cls,
  * @return how long the plugin should wait until receiving more data
  *         (plugins that do not support this, can ignore the return value)
  */
-static struct GNUNET_TIME_Relative 
+static struct GNUNET_TIME_Relative
 plugin_env_receive_callback (void *cls,
-                             const struct GNUNET_PeerIdentity *peer,
-                             const struct GNUNET_MessageHeader *message,
-                             const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count,
-                             struct Session *session,
-                             const char *sender_address,
-                             uint16_t sender_address_len)
+                             const struct GNUNET_PeerIdentity *peer,
+                             const struct GNUNET_MessageHeader *message,
+                             const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                             uint32_t ats_count, struct Session *session,
+                             const char *sender_address,
+                             uint16_t sender_address_len)
 {
   const char *plugin_name = cls;
   int do_forward;
@@ -176,80 +172,72 @@ plugin_env_receive_callback (void *cls,
 
   ret = GNUNET_TIME_UNIT_ZERO;
   if (NULL != message)
+  {
+    type = ntohs (message->type);
+    switch (type)
     {
-      type = ntohs (message->type);           
-      switch (type)
-        {
-        case GNUNET_MESSAGE_TYPE_HELLO:
-          GST_validation_handle_hello (message);
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
+    case GNUNET_MESSAGE_TYPE_HELLO:
+      GST_validation_handle_hello (message);
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-                      "Processing `%s' from `%s'\n",
-                      "PING",
-                      (sender_address != NULL)
-                      ? GST_plugins_a2s (plugin_name,
-                                         sender_address,
-                                         sender_address_len)
-                      : "<inbound>");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                  "Processing `%s' from `%s'\n",
+                  "PING",
+                  (sender_address != NULL)
+                  ? GST_plugins_a2s (plugin_name,
+                                     sender_address,
+                                     sender_address_len) : "<inbound>");
 #endif
-          GST_validation_handle_ping (peer, 
-                                      message, 
-                                      plugin_name,
-                                      session,
-                                      sender_address, sender_address_len);
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
+      GST_validation_handle_ping (peer,
+                                  message,
+                                  plugin_name,
+                                  session, sender_address, sender_address_len);
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-                      "Processing `%s' from `%s'\n",
-                      "PONG",
-                      (sender_address != NULL)
-                      ? GST_plugins_a2s (plugin_name,
-                                         sender_address,
-                                         sender_address_len)
-                      : "<inbound>");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                  "Processing `%s' from `%s'\n",
+                  "PONG",
+                  (sender_address != NULL)
+                  ? GST_plugins_a2s (plugin_name,
+                                     sender_address,
+                                     sender_address_len) : "<inbound>");
 #endif
-          GST_validation_handle_pong (peer, 
-                                      message);
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT:
-          (void) GST_blacklist_test_allowed (peer, 
-                                             NULL,
-                                             &try_connect_if_allowed, NULL);
-          /* TODO: if 'session != NULL', maybe notify ATS that this is now the preferred 
-             way to communicate with this peer (other peer switched transport) */
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT:
-          /* TODO: do some validation to prevent an attacker from sending
-             a fake disconnect message... */
-          GST_neighbours_force_disconnect (peer);
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE:
-          GST_neighbours_keepalive (peer);
-          break;
-        default:   
-          /* should be payload */
-          do_forward = GNUNET_SYSERR;
-          ret = GST_neighbours_calculate_receive_delay (peer,
-                                                        (message == NULL) 
-                                                        ? 0 
-                                                        : ntohs (message->size),
-                                                        &do_forward);
-          if (do_forward == GNUNET_YES)
-            GST_clients_broadcast (message, GNUNET_YES);
-          break;
-        }
+      GST_validation_handle_pong (peer, message);
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT:
+      (void) GST_blacklist_test_allowed (peer,
+                                         NULL, &try_connect_if_allowed, NULL);
+      /* TODO: if 'session != NULL', maybe notify ATS that this is now the preferred 
+       * way to communicate with this peer (other peer switched transport) */
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT:
+      /* TODO: do some validation to prevent an attacker from sending
+       * a fake disconnect message... */
+      GST_neighbours_force_disconnect (peer);
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE:
+      GST_neighbours_keepalive (peer);
+      break;
+    default:
+      /* should be payload */
+      do_forward = GNUNET_SYSERR;
+      ret = GST_neighbours_calculate_receive_delay (peer,
+                                                    (message == NULL)
+                                                    ? 0
+                                                    : ntohs (message->size),
+                                                    &do_forward);
+      if (do_forward == GNUNET_YES)
+        GST_clients_broadcast (message, GNUNET_YES);
+      break;
     }
-  GNUNET_ATS_address_update (GST_ats,
-                             peer,
-                             GNUNET_TIME_absolute_get (), /* valid at least until right now... */
-                             plugin_name,
-                             session,
-                             sender_address,
-                             sender_address_len,
-                             ats, ats_count);
+  }
+  GNUNET_ATS_address_update (GST_ats, peer, GNUNET_TIME_absolute_get (),        /* valid at least until right now... */
+                             plugin_name,
+                             session,
+                             sender_address,
+                             sender_address_len, ats, ats_count);
 
   return ret;
 }
@@ -266,18 +254,14 @@ plugin_env_receive_callback (void *cls,
  *        the specific address format depends on the transport
  * @param addrlen length of the address
  */
-static void 
+static void
 plugin_env_address_change_notification (void *cls,
-                                        int add_remove,
-                                        const void *addr,
-                                        size_t addrlen)
+                                        int add_remove,
+                                        const void *addr, size_t addrlen)
 {
   const char *plugin_name = cls;
 
-  GST_hello_modify_addresses (add_remove,
-                              plugin_name,
-                              addr,
-                              addrlen);
+  GST_hello_modify_addresses (add_remove, plugin_name, addr, addrlen);
 }
 
 
@@ -296,11 +280,10 @@ plugin_env_address_change_notification (void *cls,
  */
 static void
 plugin_env_session_end (void *cls,
-                        const struct GNUNET_PeerIdentity *peer,
-                        struct Session *session)
+                        const struct GNUNET_PeerIdentity *peer,
+                        struct Session *session)
 {
-  GST_neighbours_session_terminated (peer, 
-                                     session);
+  GST_neighbours_session_terminated (peer, session);
 }
 
 
@@ -319,23 +302,20 @@ plugin_env_session_end (void *cls,
  * @param plugin_addr_len number of bytes in addr
  * @param bandwidth assigned outbound bandwidth for the connection
  */
-static void 
+static void
 ats_request_address_change (void *cls,
-                            const struct GNUNET_PeerIdentity *peer,
-                            const char *plugin_name,
-                            struct Session *session,
-                            const void *plugin_addr,
-                            size_t plugin_addr_len,
-                            struct GNUNET_BANDWIDTH_Value32NBO bandwidth)
+                            const struct GNUNET_PeerIdentity *peer,
+                            const char *plugin_name,
+                            struct Session *session,
+                            const void *plugin_addr,
+                            size_t plugin_addr_len,
+                            struct GNUNET_BANDWIDTH_Value32NBO bandwidth)
 {
-  GST_neighbours_switch_to_address (peer, 
-                                    plugin_name,
-                                    plugin_addr,
-                                    plugin_addr_len,
-                                    session,
-                                    NULL, 0);
-  GST_neighbours_set_incoming_quota (peer,
-                                     bandwidth);
+  GST_neighbours_switch_to_address (peer,
+                                    plugin_name,
+                                    plugin_addr,
+                                    plugin_addr_len, session, NULL, 0);
+  GST_neighbours_set_incoming_quota (peer, bandwidth);
 }
 
 
@@ -350,23 +330,24 @@ ats_request_address_change (void *cls,
  */
 static void
 neighbours_connect_notification (void *cls,
-                                 const struct GNUNET_PeerIdentity * peer,
-                                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                                 uint32_t ats_count)
+                                 const struct GNUNET_PeerIdentity *peer,
+                                 const struct GNUNET_TRANSPORT_ATS_Information
+                                 *ats, uint32_t ats_count)
 {
-  char buf[sizeof(struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)];
-  struct ConnectInfoMessage *connect_msg = (struct ConnectInfoMessage*) buf;
+  char buf[sizeof (struct ConnectInfoMessage) +
+           ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)];
+  struct ConnectInfoMessage *connect_msg = (struct ConnectInfoMessage *) buf;
   struct GNUNET_TRANSPORT_ATS_Information *atsm = &connect_msg->ats;
 
   connect_msg->header.size = htons (sizeof (buf));
   connect_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
   connect_msg->ats_count = htonl (ats_count);
   connect_msg->id = *peer;
-  memcpy (&connect_msg->ats, ats, ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
+  memcpy (&connect_msg->ats, ats,
+          ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
   atsm[ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   atsm[ats_count].value = htonl (0);
-  GST_clients_broadcast (&connect_msg->header,
-                         GNUNET_NO);
+  GST_clients_broadcast (&connect_msg->header, GNUNET_NO);
 }
 
 
@@ -379,7 +360,7 @@ neighbours_connect_notification (void *cls,
  */
 static void
 neighbours_disconnect_notification (void *cls,
-                                    const struct GNUNET_PeerIdentity *peer)
+                                    const struct GNUNET_PeerIdentity *peer)
 {
   struct DisconnectInfoMessage disconnect_msg;
 
@@ -387,8 +368,7 @@ neighbours_disconnect_notification (void *cls,
   disconnect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
   disconnect_msg.reserved = htonl (0);
   disconnect_msg.peer = *peer;
-  GST_clients_broadcast (&disconnect_msg.header,
-                         GNUNET_NO);
+  GST_clients_broadcast (&disconnect_msg.header, GNUNET_NO);
 }
 
 
@@ -400,32 +380,32 @@ neighbours_disconnect_notification (void *cls,
  * @param tc task context (unused)
  */
 static void
-shutdown_task (void *cls, 
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
-{  
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
   GST_validation_stop ();
   GST_neighbours_stop ();
-  GNUNET_ATS_shutdown (GST_ats); GST_ats = NULL;
+  GNUNET_ATS_shutdown (GST_ats);
+  GST_ats = NULL;
   GST_clients_stop ();
   GST_blacklist_stop ();
   GST_plugins_unload ();
   GST_hello_stop ();
 
   if (GST_peerinfo != NULL)
-    {
-      GNUNET_PEERINFO_disconnect (GST_peerinfo);
-      GST_peerinfo = NULL;
-    }
+  {
+    GNUNET_PEERINFO_disconnect (GST_peerinfo);
+    GST_peerinfo = NULL;
+  }
   if (GST_stats != NULL)
-    {
-      GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
-      GST_stats = NULL;
-    }  
+  {
+    GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
+    GST_stats = NULL;
+  }
   if (GST_my_private_key != NULL)
-    {
-      GNUNET_CRYPTO_rsa_key_free (GST_my_private_key);
-      GST_my_private_key = NULL;
-    }
+  {
+    GNUNET_CRYPTO_rsa_key_free (GST_my_private_key);
+    GST_my_private_key = NULL;
+  }
 }
 
 
@@ -447,24 +427,23 @@ run (void *cls,
   GST_cfg = c;
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (c,
-                                               "GNUNETD",
-                                               "HOSTKEY", &keyfile))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
+                                               "GNUNETD", "HOSTKEY", &keyfile))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Transport service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   GST_my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (GST_my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Transport service could not access hostkey.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   GST_stats = GNUNET_STATISTICS_create ("transport", c);
   GST_peerinfo = GNUNET_PEERINFO_connect (c);
   GNUNET_CRYPTO_rsa_key_get_public (GST_my_private_key, &GST_my_public_key);
@@ -473,25 +452,23 @@ run (void *cls,
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &shutdown_task, NULL);
   if (GST_peerinfo == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not access PEERINFO service.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
-  
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not access PEERINFO service.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
   /* start subsystems */
   GST_hello_start (&process_hello_update, NULL);
   GST_blacklist_start (server);
   GST_plugins_load (&plugin_env_receive_callback,
-                    &plugin_env_address_change_notification, 
-                    &plugin_env_session_end);
-  GST_ats = GNUNET_ATS_init (GST_cfg,
-                             &ats_request_address_change, 
-                             NULL);
+                    &plugin_env_address_change_notification,
+                    &plugin_env_session_end);
+  GST_ats = GNUNET_ATS_init (GST_cfg, &ats_request_address_change, NULL);
   GST_neighbours_start (NULL,
-                        &neighbours_connect_notification,
-                        &neighbours_disconnect_notification);
+                        &neighbours_connect_notification,
+                        &neighbours_disconnect_notification);
   GST_clients_start (server);
   GST_validation_start ();
 }
@@ -511,8 +488,7 @@ main (int argc, char *const *argv)
           GNUNET_SERVICE_run (argc,
                               argv,
                               "transport",
-                              GNUNET_SERVICE_OPTION_NONE,
-                              &run, NULL)) ? 0 : 1;
+                              GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
 }
 
 /* end of file gnunet-service-transport-new.c */
diff --git a/src/transport/gnunet-service-transport.c b/src/transport/gnunet-service-transport.c
index cf02d14b2..4f962d117 100644
--- a/src/transport/gnunet-service-transport.c
+++ b/src/transport/gnunet-service-transport.c
@@ -178,9 +178,9 @@ struct ForeignAddressList
    */
   struct Session *session;
 
-  struct ATS_ressource_entry * ressources;
+  struct ATS_ressource_entry *ressources;
 
-  struct ATS_quality_entry * quality;
+  struct ATS_quality_entry *quality;
 
   /**
    * What was the last latency observed for this address, plugin and peer?
@@ -325,7 +325,7 @@ struct TransportPlugin
    */
   int rebuild;
 
-  struct ATS_plugin * rc;
+  struct ATS_plugin *rc;
 
   /**
    * Hashmap of blacklisted peers for this particular transport.
@@ -735,7 +735,7 @@ struct CheckHelloValidatedContext;
 /**
  * Entry in map of all HELLOs awaiting validation.
  */
-struct ValidationEntry 
+struct ValidationEntry
 {
 
   /**
@@ -929,10 +929,12 @@ static struct ATS_Handle *ats;
  * Time of last ats execution
  */
 struct GNUNET_TIME_Absolute last_ats_execution;
+
 /**
  * Minimum interval between two ATS executions
  */
 struct GNUNET_TIME_Relative ats_minimum_interval;
+
 /**
  * Regular interval when ATS execution is triggered
  */
@@ -961,8 +963,8 @@ static void disconnect_neighbour (struct NeighbourMapEntry *n, int check);
  */
 static void try_transmission_to_peer (struct NeighbourMapEntry *n);
 
-struct ForeignAddressList * get_preferred_ats_address (
-                struct NeighbourMapEntry *n);
+struct ForeignAddressList *get_preferred_ats_address (struct NeighbourMapEntry
+                                                      *n);
 
 /**
  * Find an entry in the neighbour list for a particular peer.
@@ -975,11 +977,14 @@ find_neighbour (const struct GNUNET_PeerIdentity *key)
   return GNUNET_CONTAINER_multihashmap_get (neighbours, &key->hashPubKey);
 }
 
-static int update_addr_value (struct ForeignAddressList *fal, uint32_t value , int ats_index)
+static int
+update_addr_value (struct ForeignAddressList *fal, uint32_t value,
+                   int ats_index)
 {
   int c;
   int set = GNUNET_NO;
-  for (c=0; c<available_quality_metrics; c++)
+
+  for (c = 0; c < available_quality_metrics; c++)
   {
     if (ats_index == qm[c].atis_index)
     {
@@ -994,7 +999,7 @@ static int update_addr_value (struct ForeignAddressList *fal, uint32_t value , i
   }
   if (set == GNUNET_NO)
   {
-    for (c=0; c<available_ressources; c++)
+    for (c = 0; c < available_ressources; c++)
     {
       if (ats_index == ressources[c].atis_index)
       {
@@ -1010,16 +1015,19 @@ static int update_addr_value (struct ForeignAddressList *fal, uint32_t value , i
 }
 
 static int
-update_addr_ats (struct ForeignAddressList *fal, 
-                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data, 
-                 int ats_count)
+update_addr_ats (struct ForeignAddressList *fal,
+                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data,
+                 int ats_count)
 {
   int c1, set;
+
   set = GNUNET_NO;
-  for (c1=0; c1<ats_count; c1++)
-    {
-      set = update_addr_value(fal, ntohl(ats_data[c1].value), ntohl(ats_data[c1].type));
-    }
+  for (c1 = 0; c1 < ats_count; c1++)
+  {
+    set =
+        update_addr_value (fal, ntohl (ats_data[c1].value),
+                           ntohl (ats_data[c1].type));
+  }
   return set;
 }
 
@@ -1032,6 +1040,7 @@ static struct TransportPlugin *
 find_transport (const char *short_name)
 {
   struct TransportPlugin *head = plugins;
+
   while ((head != NULL) && (0 != strcmp (short_name, head->short_name)))
     head = head->next;
   return head;
@@ -1046,49 +1055,51 @@ find_transport (const char *short_name)
  * @return GNUNET_YES if the peer is blacklisted, GNUNET_NO if not
  */
 static int
-is_blacklisted (const struct GNUNET_PeerIdentity *peer, struct TransportPlugin *plugin)
+is_blacklisted (const struct GNUNET_PeerIdentity *peer,
+                struct TransportPlugin *plugin)
 {
 
   if (plugin->blacklist != NULL)
+  {
+    if (GNUNET_CONTAINER_multihashmap_contains
+        (plugin->blacklist, &peer->hashPubKey) == GNUNET_YES)
     {
-      if (GNUNET_CONTAINER_multihashmap_contains (plugin->blacklist, &peer->hashPubKey) == GNUNET_YES)
-        {
 #if DEBUG_BLACKLIST
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Peer `%s:%s' is blacklisted!\n",
-                      plugin->short_name, GNUNET_i2s (peer));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Peer `%s:%s' is blacklisted!\n",
+                  plugin->short_name, GNUNET_i2s (peer));
 #endif
-          if (stats != NULL)
-            GNUNET_STATISTICS_update (stats, "# blacklisted peers refused", 1, GNUNET_NO);
-          return GNUNET_YES;
-        }
+      if (stats != NULL)
+        GNUNET_STATISTICS_update (stats, "# blacklisted peers refused", 1,
+                                  GNUNET_NO);
+      return GNUNET_YES;
     }
+  }
 
   return GNUNET_NO;
 }
 
 
 static void
-add_peer_to_blacklist (struct GNUNET_PeerIdentity *peer, 
-                       char *transport_name)
+add_peer_to_blacklist (struct GNUNET_PeerIdentity *peer, char *transport_name)
 {
   struct TransportPlugin *plugin;
 
-  plugin = find_transport(transport_name);
-  if (plugin == NULL) /* Nothing to do */
+  plugin = find_transport (transport_name);
+  if (plugin == NULL)           /* Nothing to do */
     return;
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding peer `%s' with plugin `%s' to blacklist\n",
-              GNUNET_i2s (peer),
-              transport_name);
+              "Adding peer `%s' with plugin `%s' to blacklist\n",
+              GNUNET_i2s (peer), transport_name);
 #endif
   if (plugin->blacklist == NULL)
-    plugin->blacklist = GNUNET_CONTAINER_multihashmap_create(TRANSPORT_BLACKLIST_HT_SIZE);
-  GNUNET_assert(plugin->blacklist != NULL);
-  GNUNET_CONTAINER_multihashmap_put(plugin->blacklist, &peer->hashPubKey,
-                                    NULL,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
+    plugin->blacklist =
+        GNUNET_CONTAINER_multihashmap_create (TRANSPORT_BLACKLIST_HT_SIZE);
+  GNUNET_assert (plugin->blacklist != NULL);
+  GNUNET_CONTAINER_multihashmap_put (plugin->blacklist, &peer->hashPubKey,
+                                     NULL,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
 }
 
 
@@ -1115,145 +1126,148 @@ read_blacklist_file (const struct GNUNET_CONFIGURATION_Handle *cfg)
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                "TRANSPORT",
-                                               "BLACKLIST_FILE",
-                                               &fn))
-    {
+                                               "BLACKLIST_FILE", &fn))
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Option `%s' in section `%s' not specified!\n",
-                  "BLACKLIST_FILE",
-                  "TRANSPORT");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Option `%s' in section `%s' not specified!\n",
+                "BLACKLIST_FILE", "TRANSPORT");
 #endif
-      return;
-    }
+    return;
+  }
   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
     GNUNET_DISK_fn_write (fn, NULL, 0, GNUNET_DISK_PERM_USER_READ
-        | GNUNET_DISK_PERM_USER_WRITE);
+                          | GNUNET_DISK_PERM_USER_WRITE);
   if (0 != STAT (fn, &frstat))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not read blacklist file `%s'\n"), fn);
-      GNUNET_free (fn);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not read blacklist file `%s'\n"), fn);
+    GNUNET_free (fn);
+    return;
+  }
   if (frstat.st_size == 0)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Blacklist file `%s' is empty.\n"),
-                  fn);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Blacklist file `%s' is empty.\n"), fn);
 #endif
-      GNUNET_free (fn);
-      return;
-    }
+    GNUNET_free (fn);
+    return;
+  }
   /* FIXME: use mmap */
   data = GNUNET_malloc_large (frstat.st_size);
-  GNUNET_assert(data != NULL);
-  if (frstat.st_size !=
-      GNUNET_DISK_fn_read (fn, data, frstat.st_size))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to read blacklist from `%s'\n"), fn);
-      GNUNET_free (fn);
-      GNUNET_free (data);
-      return;
-    }
+  GNUNET_assert (data != NULL);
+  if (frstat.st_size != GNUNET_DISK_fn_read (fn, data, frstat.st_size))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to read blacklist from `%s'\n"), fn);
+    GNUNET_free (fn);
+    GNUNET_free (data);
+    return;
+  }
   entries_found = 0;
   pos = 0;
-  while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
+  while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))
     pos++;
   while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
-         (pos <= frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
-    {
-      colon_pos = pos;
-      while ((colon_pos < frstat.st_size) && (data[colon_pos] != ':') && !isspace ( (unsigned char) data[colon_pos]))
-        colon_pos++;
+         (pos <=
+          frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
+  {
+    colon_pos = pos;
+    while ((colon_pos < frstat.st_size) && (data[colon_pos] != ':') &&
+           !isspace ((unsigned char) data[colon_pos]))
+      colon_pos++;
 
-      if (colon_pos >= frstat.st_size)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, giving up!\n"),
-                      (unsigned long long) colon_pos);
-          GNUNET_free (fn);
-          GNUNET_free (data);
-          return;
-        }
+    if (colon_pos >= frstat.st_size)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, giving up!\n"),
+                  (unsigned long long) colon_pos);
+      GNUNET_free (fn);
+      GNUNET_free (data);
+      return;
+    }
 
-      if (isspace( (unsigned char) data[colon_pos]))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
-                    (unsigned long long) colon_pos);
-        pos = colon_pos;
-        while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
-          pos++;
-        continue;
-      }
-      tsize = colon_pos - pos;
-      if ((pos >= frstat.st_size) || (pos + tsize >= frstat.st_size) || (tsize == 0))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, giving up!\n"),
-                      (unsigned long long) colon_pos);
-          GNUNET_free (fn);
-          GNUNET_free (data);
-          return;
-        }
+    if (isspace ((unsigned char) data[colon_pos]))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
+                  (unsigned long long) colon_pos);
+      pos = colon_pos;
+      while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))
+        pos++;
+      continue;
+    }
+    tsize = colon_pos - pos;
+    if ((pos >= frstat.st_size) || (pos + tsize >= frstat.st_size) ||
+        (tsize == 0))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, giving up!\n"),
+                  (unsigned long long) colon_pos);
+      GNUNET_free (fn);
+      GNUNET_free (data);
+      return;
+    }
 
-      if (tsize < 1)
-        continue;
+    if (tsize < 1)
+      continue;
 
-      transport_name = GNUNET_malloc(tsize + 1);
-      memcpy(transport_name, &data[pos], tsize);
-      pos = colon_pos + 1;
+    transport_name = GNUNET_malloc (tsize + 1);
+    memcpy (transport_name, &data[pos], tsize);
+    pos = colon_pos + 1;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Read transport name %s in blacklist file.\n",
-                  transport_name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Read transport name %s in blacklist file.\n", transport_name);
 #endif
-      memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
-      if (!isspace ( (unsigned char) enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
-                      (unsigned long long) pos);
-          pos++;
-          while ((pos < frstat.st_size) && (!isspace ( (unsigned char) data[pos])))
-            pos++;
-          GNUNET_free_non_null(transport_name);
-          continue;
-        }
-      enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
-      if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, skipping bytes `%s'.\n"),
-                      (unsigned long long) pos,
-                      &enc);
-        }
-      else
-        {
-          if (0 != memcmp (&pid,
-                           &my_identity,
-                           sizeof (struct GNUNET_PeerIdentity)))
-            {
-              entries_found++;
-              add_peer_to_blacklist (&pid,
-                                     transport_name);
-            }
-          else
-            {
-              GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                          _("Found myself `%s' in blacklist (useless, ignored)\n"),
-                          GNUNET_i2s (&pid));
-            }
-        }
-      pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
-      GNUNET_free_non_null(transport_name);
-      while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
+    memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+    if (!isspace
+        ((unsigned char)
+         enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
+                  (unsigned long long) pos);
+      pos++;
+      while ((pos < frstat.st_size) && (!isspace ((unsigned char) data[pos])))
         pos++;
+      GNUNET_free_non_null (transport_name);
+      continue;
+    }
+    enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, skipping bytes `%s'.\n"),
+                  (unsigned long long) pos, &enc);
     }
-  GNUNET_STATISTICS_update (stats, "# Transport entries blacklisted", entries_found, GNUNET_NO);
+    else
+    {
+      if (0 != memcmp (&pid, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+      {
+        entries_found++;
+        add_peer_to_blacklist (&pid, transport_name);
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _("Found myself `%s' in blacklist (useless, ignored)\n"),
+                    GNUNET_i2s (&pid));
+      }
+    }
+    pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
+    GNUNET_free_non_null (transport_name);
+    while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))
+      pos++;
+  }
+  GNUNET_STATISTICS_update (stats, "# Transport entries blacklisted",
+                            entries_found, GNUNET_NO);
   GNUNET_free (data);
   GNUNET_free (fn);
 }
@@ -1281,57 +1295,56 @@ transmit_to_client_callback (void *cls, size_t size, void *buf)
 
   client->th = NULL;
   if (buf == NULL)
-    {
-#if DEBUG_TRANSPORT 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission to client failed, closing connection.\n");
+  {
+#if DEBUG_TRANSPORT
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission to client failed, closing connection.\n");
 #endif
-      /* fatal error with client, free message queue! */
-      while (NULL != (q = client->message_queue_head))
-        {
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# bytes discarded (could not transmit to client)"),
-                                    ntohs (((const struct GNUNET_MessageHeader*)&q[1])->size),
-                                    GNUNET_NO);
-          GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
-                                       client->message_queue_tail,
-                                       q);
-          GNUNET_free (q);
-        }
-      client->message_count = 0;
-      return 0;
+    /* fatal error with client, free message queue! */
+    while (NULL != (q = client->message_queue_head))
+    {
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# bytes discarded (could not transmit to client)"),
+                                ntohs (((const struct GNUNET_MessageHeader *)
+                                        &q[1])->size), GNUNET_NO);
+      GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
+                                   client->message_queue_tail, q);
+      GNUNET_free (q);
     }
+    client->message_count = 0;
+    return 0;
+  }
   cbuf = buf;
   tsize = 0;
   while (NULL != (q = client->message_queue_head))
-    {
-      msg = (const struct GNUNET_MessageHeader *) &q[1];
-      msize = ntohs (msg->size);
-      if (msize + tsize > size)
-        break;
+  {
+    msg = (const struct GNUNET_MessageHeader *) &q[1];
+    msize = ntohs (msg->size);
+    if (msize + tsize > size)
+      break;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting message of type %u to client.\n",
-                  ntohs (msg->type));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting message of type %u to client.\n",
+                ntohs (msg->type));
 #endif
-      GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
-                                   client->message_queue_tail,
-                                   q);
-      memcpy (&cbuf[tsize], msg, msize);
-      tsize += msize;
-      GNUNET_free (q);
-      client->message_count--;
-    }
+    GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
+                                 client->message_queue_tail, q);
+    memcpy (&cbuf[tsize], msg, msize);
+    tsize += msize;
+    GNUNET_free (q);
+    client->message_count--;
+  }
   if (NULL != q)
-    {
-      GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
-      client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
-                                                        msize,
-                                                        GNUNET_TIME_UNIT_FOREVER_REL,
-                                                        &transmit_to_client_callback,
-                                                        client);
-      GNUNET_assert (client->th != NULL);
-    }
+  {
+    GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
+    client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
+                                                      msize,
+                                                      GNUNET_TIME_UNIT_FOREVER_REL,
+                                                      &transmit_to_client_callback,
+                                                      client);
+    GNUNET_assert (client->th != NULL);
+  }
   return tsize;
 }
 
@@ -1344,10 +1357,8 @@ transmit_to_client_callback (void *cls, size_t size, void *buf)
  * @param addr_len number of bytes in addr
  * @return NULL on error, otherwise address string
  */
-static const char*
-a2s (const char *plugin,
-     const void *addr,
-     uint16_t addr_len)
+static const char *
+a2s (const char *plugin, const void *addr, uint16_t addr_len)
 {
   struct TransportPlugin *p;
 
@@ -1356,9 +1367,7 @@ a2s (const char *plugin,
   p = find_transport (plugin);
   if ((p == NULL) || (addr_len == 0) || (addr == NULL))
     return NULL;
-  return p->api->address_to_string (NULL,
-                                    addr,
-                                    addr_len);
+  return p->api->address_to_string (NULL, addr, addr_len);
 }
 
 
@@ -1373,9 +1382,7 @@ a2s (const char *plugin,
  * @return GNUNET_YES (always)
  */
 static int
-abort_validation (void *cls,
-                  const GNUNET_HashCode * key,
-                  void *value)
+abort_validation (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct ValidationEntry *va = value;
 
@@ -1383,17 +1390,15 @@ abort_validation (void *cls,
     GNUNET_SCHEDULER_cancel (va->timeout_task);
   GNUNET_free (va->transport_name);
   if (va->chvc != NULL)
+  {
+    va->chvc->ve_count--;
+    if (va->chvc->ve_count == 0)
     {
-      va->chvc->ve_count--;
-      if (va->chvc->ve_count == 0)
-        {
-          GNUNET_CONTAINER_DLL_remove (chvc_head,
-                                       chvc_tail,
-                                       va->chvc);
-          GNUNET_free (va->chvc);
-        }
-      va->chvc = NULL;
+      GNUNET_CONTAINER_DLL_remove (chvc_head, chvc_tail, va->chvc);
+      GNUNET_free (va->chvc);
     }
+    va->chvc = NULL;
+  }
   GNUNET_free (va);
   return GNUNET_YES;
 }
@@ -1406,24 +1411,23 @@ abort_validation (void *cls,
  * @param tc scheduler context (unused)
  */
 static void
-timeout_hello_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_hello_validation (void *cls,
+                          const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ValidationEntry *va = cls;
   struct GNUNET_PeerIdentity pid;
 
   va->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# address validation timeouts"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# address validation timeouts"),
+                            1, GNUNET_NO);
   GNUNET_CRYPTO_hash (&va->publicKey,
-                      sizeof (struct
-                              GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &pid.hashPubKey);
+                      sizeof (struct
+                              GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &pid.hashPubKey);
   GNUNET_break (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_remove (validation_map,
-                                                      &pid.hashPubKey,
-                                                      va));
+                                                      &pid.hashPubKey, va));
   abort_validation (NULL, NULL, va);
 }
 
@@ -1450,43 +1454,40 @@ transmit_to_client (struct TransportClient *client,
    * freed in client_disconnect_notification
    */
   if (client->client == NULL)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
 
   if ((client->message_count >= MAX_PENDING) && (GNUNET_YES == may_drop))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _
-                  ("Dropping message of type %u and size %u, have %u messages pending (%u is the soft limit)\n"),
-                  ntohs (msg->type),
-                  ntohs (msg->size),
-                  client->message_count,
-                  MAX_PENDING);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# messages dropped due to slow client"),
-                                1,
-                                GNUNET_NO);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Dropping message of type %u and size %u, have %u messages pending (%u is the soft limit)\n"),
+                ntohs (msg->type),
+                ntohs (msg->size), client->message_count, MAX_PENDING);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# messages dropped due to slow client"), 1,
+                              GNUNET_NO);
+    return;
+  }
   msize = ntohs (msg->size);
   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
   q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize);
   memcpy (&q[1], msg, msize);
   GNUNET_CONTAINER_DLL_insert_tail (client->message_queue_head,
-                                    client->message_queue_tail,
-                                    q);
+                                    client->message_queue_tail, q);
   client->message_count++;
   if (client->th == NULL)
-    {
-      client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
-                                                        msize,
-                                                        GNUNET_TIME_UNIT_FOREVER_REL,
-                                                        &transmit_to_client_callback,
-                                                        client);
-      GNUNET_assert (client->th != NULL);
-    }
+  {
+    client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
+                                                      msize,
+                                                      GNUNET_TIME_UNIT_FOREVER_REL,
+                                                      &transmit_to_client_callback,
+                                                      client);
+    GNUNET_assert (client->th != NULL);
+  }
 }
 
 
@@ -1501,9 +1502,8 @@ transmit_to_client (struct TransportClient *client,
  */
 static void
 transmit_send_ok (struct TransportClient *client,
-                  struct NeighbourMapEntry *n,
-                  const struct GNUNET_PeerIdentity *target,
-                  int result)
+                  struct NeighbourMapEntry *n,
+                  const struct GNUNET_PeerIdentity *target, int result)
 {
   struct SendOkMessage send_ok_msg;
 
@@ -1513,7 +1513,8 @@ transmit_send_ok (struct TransportClient *client,
   if (n != NULL)
     send_ok_msg.latency = GNUNET_TIME_relative_hton (n->latency);
   else
-    send_ok_msg.latency = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_FOREVER_REL);
+    send_ok_msg.latency =
+        GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_FOREVER_REL);
   send_ok_msg.peer = *target;
   transmit_to_client (client, &send_ok_msg.header, GNUNET_NO);
 }
@@ -1526,8 +1527,7 @@ transmit_send_ok (struct TransportClient *client,
  *
  * @param fal address to set to 'connected'
  */
-static void
-mark_address_connected (struct ForeignAddressList *fal);
+static void mark_address_connected (struct ForeignAddressList *fal);
 
 
 
@@ -1537,7 +1537,7 @@ mark_address_connected (struct ForeignAddressList *fal);
  */
 static void
 retry_transmission_task (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct NeighbourMapEntry *n = cls;
 
@@ -1569,67 +1569,62 @@ transmit_send_continuation (void *cls,
   struct NeighbourMapEntry *n;
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# bytes pending with plugins"),
-                            - (int64_t) mq->message_buf_size,
-                            GNUNET_NO);
+                            gettext_noop ("# bytes pending with plugins"),
+                            -(int64_t) mq->message_buf_size, GNUNET_NO);
   if (result == GNUNET_OK)
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes successfully transmitted by plugins"),
-                                mq->message_buf_size,
-                                GNUNET_NO);
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# bytes successfully transmitted by plugins"),
+                              mq->message_buf_size, GNUNET_NO);
+  }
   else
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# bytes with transmission failure by plugins"),
+                              mq->message_buf_size, GNUNET_NO);
+  }
+  if (mq->specific_address != NULL)
+  {
+    if (result == GNUNET_OK)
     {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes with transmission failure by plugins"),
-                                mq->message_buf_size,
-                                GNUNET_NO);
+      mq->specific_address->timeout =
+          GNUNET_TIME_relative_to_absolute
+          (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+      if (mq->specific_address->validated == GNUNET_YES)
+        mark_address_connected (mq->specific_address);
     }
-  if (mq->specific_address != NULL)
+    else
     {
-      if (result == GNUNET_OK)
-        {
-          mq->specific_address->timeout =
-            GNUNET_TIME_relative_to_absolute
-            (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
-          if (mq->specific_address->validated == GNUNET_YES)
-            mark_address_connected (mq->specific_address);
-        }
-      else
-        {
-          if (mq->specific_address->connected == GNUNET_YES)
-            {
+      if (mq->specific_address->connected == GNUNET_YES)
+      {
 #if DEBUG_TRANSPORT
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Marking address `%s' as no longer connected (due to transmission problem)\n",
-                          a2s (mq->specific_address->ready_list->plugin->short_name,
-                               mq->specific_address->addr,
-                               mq->specific_address->addrlen));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Marking address `%s' as no longer connected (due to transmission problem)\n",
+                    a2s (mq->specific_address->ready_list->plugin->short_name,
+                         mq->specific_address->addr,
+                         mq->specific_address->addrlen));
 #endif
-              GNUNET_STATISTICS_update (stats,
-                                        gettext_noop ("# connected addresses"),
-                                        -1,
-                                        GNUNET_NO);
-              mq->specific_address->connected = GNUNET_NO;
-            }
-        }
-      if (! mq->internal_msg)
-        mq->specific_address->in_transmit = GNUNET_NO;
+        GNUNET_STATISTICS_update (stats,
+                                  gettext_noop ("# connected addresses"),
+                                  -1, GNUNET_NO);
+        mq->specific_address->connected = GNUNET_NO;
+      }
     }
+    if (!mq->internal_msg)
+      mq->specific_address->in_transmit = GNUNET_NO;
+  }
   n = find_neighbour (&mq->neighbour_id);
   if (mq->client != NULL)
     transmit_send_ok (mq->client, n, target, result);
   GNUNET_assert (n != NULL);
-  GNUNET_CONTAINER_DLL_remove (n->cont_head,
-                               n->cont_tail,
-                               mq);
+  GNUNET_CONTAINER_DLL_remove (n->cont_head, n->cont_tail, mq);
   GNUNET_free (mq);
-  if (result == GNUNET_OK) 
+  if (result == GNUNET_OK)
     try_transmission_to_peer (n);
   else if (GNUNET_SCHEDULER_NO_TASK == n->retry_task)
-    n->retry_task = GNUNET_SCHEDULER_add_now (&retry_transmission_task,
-                                              n);
+    n->retry_task = GNUNET_SCHEDULER_add_now (&retry_transmission_task, n);
 }
 
 
@@ -1649,81 +1644,73 @@ try_transmission_to_peer (struct NeighbourMapEntry *n)
   int force_address;
 
   if (n->messages_head == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission queue for `%4s' is empty\n",
-                  GNUNET_i2s (&n->id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission queue for `%4s' is empty\n", GNUNET_i2s (&n->id));
 #endif
-      return;                     /* nothing to do */
-    }
+    return;                     /* nothing to do */
+  }
   rl = NULL;
   mq = n->messages_head;
   force_address = GNUNET_YES;
   if (mq->specific_address == NULL)
-    {
-      /* TODO: ADD ATS */
-      mq->specific_address = get_preferred_ats_address(n);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# transport selected peer address freely"),
-                                1,
-                                GNUNET_NO);
-      force_address = GNUNET_NO;
-    }
+  {
+    /* TODO: ADD ATS */
+    mq->specific_address = get_preferred_ats_address (n);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# transport selected peer address freely"), 1,
+                              GNUNET_NO);
+    force_address = GNUNET_NO;
+  }
   if (mq->specific_address == NULL)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# transport failed to selected peer address"),
+                              1, GNUNET_NO);
+    timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
+    if (timeout.rel_value == 0)
     {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# transport failed to selected peer address"),
-                                1,
-                                GNUNET_NO);
-      timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
-      if (timeout.rel_value == 0)
-        {
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "No destination address available to transmit message of size %u to peer `%4s'\n",
-                      mq->message_buf_size,
-                      GNUNET_i2s (&mq->neighbour_id));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "No destination address available to transmit message of size %u to peer `%4s'\n",
+                  mq->message_buf_size, GNUNET_i2s (&mq->neighbour_id));
 #endif
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# bytes in message queue for other peers"),
-                                    - (int64_t) mq->message_buf_size,
-                                    GNUNET_NO);
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# bytes discarded (no destination address available)"),
-                                    mq->message_buf_size,
-                                    GNUNET_NO);
-          if (mq->client != NULL)
-            transmit_send_ok (mq->client, n, &n->id, GNUNET_NO);
-          GNUNET_CONTAINER_DLL_remove (n->messages_head,
-                                       n->messages_tail,
-                                       mq);
-          GNUNET_free (mq);
-          return;               /* nobody ready */
-        }
       GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# message delivery deferred (no address)"),
-                                1,
-                                GNUNET_NO);
-      if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (n->retry_task);
-      n->retry_task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                                    &retry_transmission_task,
-                                                    n);
+                                gettext_noop
+                                ("# bytes in message queue for other peers"),
+                                -(int64_t) mq->message_buf_size, GNUNET_NO);
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# bytes discarded (no destination address available)"),
+                                mq->message_buf_size, GNUNET_NO);
+      if (mq->client != NULL)
+        transmit_send_ok (mq->client, n, &n->id, GNUNET_NO);
+      GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
+      GNUNET_free (mq);
+      return;                   /* nobody ready */
+    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# message delivery deferred (no address)"), 1,
+                              GNUNET_NO);
+    if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (n->retry_task);
+    n->retry_task = GNUNET_SCHEDULER_add_delayed (timeout,
+                                                  &retry_transmission_task, n);
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No validated destination address available to transmit message of size %u to peer `%4s', will wait %llums to find an address.\n",
-                  mq->message_buf_size,
-                  GNUNET_i2s (&mq->neighbour_id),
-                  timeout.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No validated destination address available to transmit message of size %u to peer `%4s', will wait %llums to find an address.\n",
+                mq->message_buf_size,
+                GNUNET_i2s (&mq->neighbour_id), timeout.rel_value);
 #endif
-      /* FIXME: might want to trigger peerinfo lookup here
-         (unless that's already pending...) */
-      return;
-    }
-  GNUNET_CONTAINER_DLL_remove (n->messages_head,
-                               n->messages_tail,
-                               mq);
+    /* FIXME: might want to trigger peerinfo lookup here
+     * (unless that's already pending...) */
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
   if (mq->specific_address->connected == GNUNET_NO)
     mq->specific_address->connect_attempts++;
   rl = mq->specific_address->ready_list;
@@ -1735,45 +1722,38 @@ try_transmission_to_peer (struct NeighbourMapEntry *n)
               "Sending message of size %u for `%4s' to `%s' via plugin `%s'\n",
               mq->message_buf_size,
               GNUNET_i2s (&n->id),
-              (mq->specific_address->addr != NULL)
-              ? a2s (mq->plugin->short_name,
-                     mq->specific_address->addr,
-                     mq->specific_address->addrlen)
-              : "<inbound>",
-              rl->plugin->short_name);
+              (mq->specific_address->addr != NULL)
+              ? a2s (mq->plugin->short_name,
+                     mq->specific_address->addr,
+                     mq->specific_address->addrlen)
+              : "<inbound>", rl->plugin->short_name);
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# bytes in message queue for other peers"),
-                            - (int64_t) mq->message_buf_size,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# bytes in message queue for other peers"),
+                            -(int64_t) mq->message_buf_size, GNUNET_NO);
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# bytes pending with plugins"),
-                            mq->message_buf_size,
-                            GNUNET_NO);
+                            gettext_noop ("# bytes pending with plugins"),
+                            mq->message_buf_size, GNUNET_NO);
 
-  GNUNET_CONTAINER_DLL_insert (n->cont_head,
-                               n->cont_tail,
-                               mq);
+  GNUNET_CONTAINER_DLL_insert (n->cont_head, n->cont_tail, mq);
 
   ret = rl->plugin->api->send (rl->plugin->api->cls,
-                               &mq->neighbour_id,
-                               mq->message_buf,
-                               mq->message_buf_size,
-                               mq->priority,
-                               GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                               mq->specific_address->session,
-                               mq->specific_address->addr,
-                               mq->specific_address->addrlen,
-                               force_address,
-                               &transmit_send_continuation, mq);
+                               &mq->neighbour_id,
+                               mq->message_buf,
+                               mq->message_buf_size,
+                               mq->priority,
+                               GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                               mq->specific_address->session,
+                               mq->specific_address->addr,
+                               mq->specific_address->addrlen,
+                               force_address, &transmit_send_continuation, mq);
   if (ret == -1)
-    {
-      /* failure, but 'send' would not call continuation in this case,
-         so we need to do it here! */
-      transmit_send_continuation (mq,
-                                  &mq->neighbour_id,
-                                  GNUNET_SYSERR);
-    }
+  {
+    /* failure, but 'send' would not call continuation in this case,
+     * so we need to do it here! */
+    transmit_send_continuation (mq, &mq->neighbour_id, GNUNET_SYSERR);
+  }
 }
 
 
@@ -1794,7 +1774,7 @@ static void
 transmit_to_peer (struct TransportClient *client,
                   struct ForeignAddressList *peer_address,
                   unsigned int priority,
-                  struct GNUNET_TIME_Relative timeout,
+                  struct GNUNET_TIME_Relative timeout,
                   const char *message_buf,
                   size_t message_buf_size,
                   int is_internal, struct NeighbourMapEntry *neighbour)
@@ -1803,46 +1783,45 @@ transmit_to_peer (struct TransportClient *client,
 
 #if EXTRA_CHECKS
   if (client != NULL)
+  {
+    /* check for duplicate submission */
+    mq = neighbour->messages_head;
+    while (NULL != mq)
     {
-      /* check for duplicate submission */
-      mq = neighbour->messages_head;
-      while (NULL != mq)
-        {
-          if (mq->client == client)
-            {
-              /* client transmitted to same peer twice
-                 before getting SEND_OK! */
-              GNUNET_break (0);
-              return;
-            }
-          mq = mq->next;
-        }
+      if (mq->client == client)
+      {
+        /* client transmitted to same peer twice
+         * before getting SEND_OK! */
+        GNUNET_break (0);
+        return;
+      }
+      mq = mq->next;
     }
+  }
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# bytes in message queue for other peers"),
-                            message_buf_size,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# bytes in message queue for other peers"),
+                            message_buf_size, GNUNET_NO);
   mq = GNUNET_malloc (sizeof (struct MessageQueue) + message_buf_size);
   mq->specific_address = peer_address;
   mq->client = client;
   /* FIXME: this memcpy can be up to 7% of our total runtime! */
   memcpy (&mq[1], message_buf, message_buf_size);
-  mq->message_buf = (const char*) &mq[1];
+  mq->message_buf = (const char *) &mq[1];
   mq->message_buf_size = message_buf_size;
-  memcpy(&mq->neighbour_id, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
+  memcpy (&mq->neighbour_id, &neighbour->id,
+          sizeof (struct GNUNET_PeerIdentity));
   mq->internal_msg = is_internal;
   mq->priority = priority;
   mq->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   if (is_internal)
     GNUNET_CONTAINER_DLL_insert (neighbour->messages_head,
-                                 neighbour->messages_tail,
-                                 mq);
+                                 neighbour->messages_tail, mq);
   else
     GNUNET_CONTAINER_DLL_insert_after (neighbour->messages_head,
-                                       neighbour->messages_tail,
-                                       neighbour->messages_tail,
-                                       mq);
+                                       neighbour->messages_tail,
+                                       neighbour->messages_tail, mq);
   try_transmission_to_peer (neighbour);
 }
 
@@ -1863,62 +1842,56 @@ transmit_plain_ping (struct NeighbourMapEntry *n)
   struct TransportPlugin *plugin;
   struct ForeignAddressList *fal;
 
-  if (! n->public_key_valid)
-    {
-      /* This should not happen since the other peer
-         should send us a HELLO prior to sending his
-         PING */
-      GNUNET_break_op (0);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Could not transmit plain PING to `%s': public key not known\n",
-                  GNUNET_i2s (&n->id));
-      return;
-    }
+  if (!n->public_key_valid)
+  {
+    /* This should not happen since the other peer
+     * should send us a HELLO prior to sending his
+     * PING */
+    GNUNET_break_op (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Could not transmit plain PING to `%s': public key not known\n",
+                GNUNET_i2s (&n->id));
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Looking for addresses to transmit plain PING to `%s'\n",
-              GNUNET_i2s (&n->id));
+              "Looking for addresses to transmit plain PING to `%s'\n",
+              GNUNET_i2s (&n->id));
   for (rl = n->plugins; rl != NULL; rl = rl->next)
+  {
+    plugin = rl->plugin;
+    for (fal = rl->addresses; fal != NULL; fal = fal->next)
     {
-      plugin = rl->plugin;
-      for (fal = rl->addresses; fal != NULL; fal = fal->next)
-        {
-          if (! fal->connected)
-            continue;      
-          ve = GNUNET_malloc (sizeof (struct ValidationEntry));
-          ve->transport_name = GNUNET_strdup (plugin->short_name);
-          ve->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                                    UINT_MAX);
-          ve->send_time = GNUNET_TIME_absolute_get();
-          ve->session = fal->session;
-          memcpy(&ve->publicKey,
-                 &n->publicKey,
-                 sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
-          ve->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
-                                                           &timeout_hello_validation,
-                                                           ve);
-          GNUNET_CONTAINER_multihashmap_put (validation_map,
-                                             &n->id.hashPubKey,
-                                             ve,
-                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-          ping.header.size = htons(sizeof(struct TransportPingMessage));
-          ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
-          ping.challenge = htonl(ve->challenge);
-          memcpy(&ping.target, &n->id, sizeof(struct GNUNET_PeerIdentity));
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# PING without HELLO messages sent"),
-                                    1,
-                                    GNUNET_NO);
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Transmitting plain PING to `%s'\n",
-                      GNUNET_i2s (&n->id));
-          transmit_to_peer (NULL, 
-                            fal,
-                            GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                            HELLO_VERIFICATION_TIMEOUT,
-                            (const char*) &ping, sizeof (ping),
-                            GNUNET_YES, n);
-        }
+      if (!fal->connected)
+        continue;
+      ve = GNUNET_malloc (sizeof (struct ValidationEntry));
+      ve->transport_name = GNUNET_strdup (plugin->short_name);
+      ve->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
+                                                UINT_MAX);
+      ve->send_time = GNUNET_TIME_absolute_get ();
+      ve->session = fal->session;
+      memcpy (&ve->publicKey,
+              &n->publicKey,
+              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+      ve->timeout_task =
+          GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
+                                        &timeout_hello_validation, ve);
+      GNUNET_CONTAINER_multihashmap_put (validation_map, &n->id.hashPubKey, ve,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+      ping.header.size = htons (sizeof (struct TransportPingMessage));
+      ping.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
+      ping.challenge = htonl (ve->challenge);
+      memcpy (&ping.target, &n->id, sizeof (struct GNUNET_PeerIdentity));
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# PING without HELLO messages sent"), 1,
+                                GNUNET_NO);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting plain PING to `%s'\n",
+                  GNUNET_i2s (&n->id));
+      transmit_to_peer (NULL, fal, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                        HELLO_VERIFICATION_TIMEOUT, (const char *) &ping,
+                        sizeof (ping), GNUNET_YES, n);
     }
+  }
 }
 
 
@@ -1930,7 +1903,7 @@ transmit_plain_ping (struct NeighbourMapEntry *n)
  * @param fal address to set to 'connected'
  */
 static void
-mark_address_connected(struct ForeignAddressList *fal)
+mark_address_connected (struct ForeignAddressList *fal)
 {
   struct ForeignAddressList *pos;
   struct ForeignAddressList *inbound;
@@ -1938,92 +1911,102 @@ mark_address_connected(struct ForeignAddressList *fal)
 
   GNUNET_assert (GNUNET_YES == fal->validated);
   if (fal->connected == GNUNET_YES)
-    return; /* nothing to do */
+    return;                     /* nothing to do */
   inbound = NULL;
   outbound = NULL;
 
   pos = fal->ready_list->addresses;
   while (pos != NULL)
-    {
-      /* Already have inbound address, and this is also an inbound address, don't switch!! */
-      if ( (GNUNET_YES == pos->connected) && 
-           (0 == pos->addrlen) && 
-           (0 == fal->addrlen) )
-        return;
-      if ( (0 == pos->addrlen) && 
-           (GNUNET_YES == pos->connected) )
-        inbound = pos;
-      pos = pos->next;
-    }
+  {
+    /* Already have inbound address, and this is also an inbound address, don't switch!! */
+    if ((GNUNET_YES == pos->connected) &&
+        (0 == pos->addrlen) && (0 == fal->addrlen))
+      return;
+    if ((0 == pos->addrlen) && (GNUNET_YES == pos->connected))
+      inbound = pos;
+    pos = pos->next;
+  }
 
   pos = fal->ready_list->addresses;
   while (pos != NULL)
-    {
-      /* Already have outbound address, and this is also an outbound address, don't switch!! */
-      if ( (GNUNET_YES == pos->connected) && 
-           (0 < pos->addrlen) && 
-           (0 < fal->addrlen) )
-        return;
-      if ( (0 < pos->addrlen) && (GNUNET_YES == pos->connected) )
-        outbound = pos;
-      pos = pos->next;
-    }
+  {
+    /* Already have outbound address, and this is also an outbound address, don't switch!! */
+    if ((GNUNET_YES == pos->connected) &&
+        (0 < pos->addrlen) && (0 < fal->addrlen))
+      return;
+    if ((0 < pos->addrlen) && (GNUNET_YES == pos->connected))
+      outbound = pos;
+    pos = pos->next;
+  }
 
 #if DEBUG_INBOUND
   if (inbound != NULL)
-    fprintf(stderr, "Peer: %s, have inbound connection.\n", GNUNET_i2s(&my_identity));
+    fprintf (stderr, "Peer: %s, have inbound connection.\n",
+             GNUNET_i2s (&my_identity));
   if (outbound != NULL)
-    fprintf(stderr, "Peer: %s, have outbound connection.\n", GNUNET_i2s(&my_identity));
+    fprintf (stderr, "Peer: %s, have outbound connection.\n",
+             GNUNET_i2s (&my_identity));
 #endif
 
   /* Have an inbound connection to this peer which is valid; our id is lower, ignore outbound connection! */
   if ((inbound != NULL) && (0 != fal->addrlen) && (1
-      == GNUNET_CRYPTO_hash_xorcmp (&inbound->ready_list->neighbour->id.hashPubKey,
-                                    &my_identity.hashPubKey, &null_hash)))
-    {
+                                                   ==
+                                                   GNUNET_CRYPTO_hash_xorcmp
+                                                   (&inbound->
+                                                    ready_list->neighbour->id.
+                                                    hashPubKey,
+                                                    &my_identity.hashPubKey,
+                                                    &null_hash)))
+  {
 #if DEBUG_INBOUND
-      fprintf(stderr, "Peer: %s, had inbound connection, ignoring outbound!\n", GNUNET_i2s(&my_identity));
+    fprintf (stderr, "Peer: %s, had inbound connection, ignoring outbound!\n",
+             GNUNET_i2s (&my_identity));
 #endif
-      return;
-    }
+    return;
+  }
   else if ((outbound != NULL) && (0 == fal->addrlen) && ((-1
-      == GNUNET_CRYPTO_hash_xorcmp (&outbound->ready_list->neighbour->id.hashPubKey,
-                                    &my_identity.hashPubKey, &null_hash))))
-    {
+                                                          ==
+                                                          GNUNET_CRYPTO_hash_xorcmp
+                                                          (&outbound->ready_list->neighbour->
+                                                           id.hashPubKey,
+                                                           &my_identity.hashPubKey,
+                                                           &null_hash))))
+  {
 #if DEBUG_INBOUND
-      fprintf(stderr, "Peer: %s, have outbound connection, ignoring inbound!\n", GNUNET_i2s(&my_identity));
+    fprintf (stderr, "Peer: %s, have outbound connection, ignoring inbound!\n",
+             GNUNET_i2s (&my_identity));
 #endif
-      return;
-    }
+    return;
+  }
 
   pos = fal->ready_list->addresses;
   while (pos != NULL)
+  {
+    if ((GNUNET_YES == pos->connected) && (0 < pos->addrlen))
     {
-      if ((GNUNET_YES == pos->connected) && (0 < pos->addrlen))
-        {
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Marking address `%s' as no longer connected (due to connect on other address)\n",
-                      a2s (pos->ready_list->plugin->short_name, pos->addr,
-                           pos->addrlen));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Marking address `%s' as no longer connected (due to connect on other address)\n",
+                  a2s (pos->ready_list->plugin->short_name, pos->addr,
+                       pos->addrlen));
 #endif
 #if DEBUG_INBOUND
-          fprintf(stderr, 
-                  "Peer: %s, setting %s connection to disconnected.\n", 
-                  GNUNET_i2s(&my_identity),
-                  (0 == pos->addrlen) ? "INBOUND" : "OUTBOUND");
+      fprintf (stderr,
+               "Peer: %s, setting %s connection to disconnected.\n",
+               GNUNET_i2s (&my_identity),
+               (0 == pos->addrlen) ? "INBOUND" : "OUTBOUND");
 #endif
-          pos->connected = GNUNET_NO;
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# connected addresses"), -1,
-                                    GNUNET_NO);
-        }
-      pos = pos->next;
+      pos->connected = GNUNET_NO;
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop ("# connected addresses"), -1,
+                                GNUNET_NO);
     }
+    pos = pos->next;
+  }
   GNUNET_assert (GNUNET_NO == fal->connected);
   fal->connected = GNUNET_YES;
   GNUNET_STATISTICS_update (stats, gettext_noop ("# connected addresses"),
-                            1, GNUNET_NO);
+                            1, GNUNET_NO);
 }
 
 
@@ -2037,7 +2020,7 @@ mark_address_connected(struct ForeignAddressList *fal)
  * @return selected address, NULL if we have none
  */
 struct ForeignAddressList *
-find_ready_address(struct NeighbourMapEntry *neighbour)
+find_ready_address (struct NeighbourMapEntry *neighbour)
 {
   struct ReadyList *head = neighbour->plugins;
   struct ForeignAddressList *addresses;
@@ -2049,95 +2032,93 @@ find_ready_address(struct NeighbourMapEntry *neighbour)
 
   best_address = NULL;
   while (head != NULL)
+  {
+    addresses = head->addresses;
+    while (addresses != NULL)
     {
-      addresses = head->addresses;
-      while (addresses != NULL)
-        {
-          if ( (addresses->timeout.abs_value < now.abs_value) &&
-               (addresses->connected == GNUNET_YES) )
-            {
+      if ((addresses->timeout.abs_value < now.abs_value) &&
+          (addresses->connected == GNUNET_YES))
+      {
 #if DEBUG_TRANSPORT
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Marking long-time inactive connection to `%4s' as down.\n",
-                          GNUNET_i2s (&neighbour->id));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Marking long-time inactive connection to `%4s' as down.\n",
+                    GNUNET_i2s (&neighbour->id));
 #endif
-              GNUNET_STATISTICS_update (stats,
-                                        gettext_noop ("# connected addresses"),
-                                        -1,
-                                        GNUNET_NO);
-              addresses->connected = GNUNET_NO;
-            }
-          addresses = addresses->next;
-        }
+        GNUNET_STATISTICS_update (stats,
+                                  gettext_noop ("# connected addresses"),
+                                  -1, GNUNET_NO);
+        addresses->connected = GNUNET_NO;
+      }
+      addresses = addresses->next;
+    }
 
-      addresses = head->addresses;
-      while (addresses != NULL)
-        {
+    addresses = head->addresses;
+    while (addresses != NULL)
+    {
 #if DEBUG_TRANSPORT
-          if (addresses->addr != NULL)
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                        "Have address `%s' for peer `%4s' (status: %d, %d, %d, %u, %llums, %u)\n",
-                        a2s (head->plugin->short_name,
-                             addresses->addr,
-                             addresses->addrlen),
-                        GNUNET_i2s (&neighbour->id),
-                        addresses->connected,
-                        addresses->in_transmit,
-                        addresses->validated,
-                        addresses->connect_attempts,
-                        (unsigned long long) addresses->timeout.abs_value,
-                        (unsigned int) addresses->distance);
+      if (addresses->addr != NULL)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Have address `%s' for peer `%4s' (status: %d, %d, %d, %u, %llums, %u)\n",
+                    a2s (head->plugin->short_name,
+                         addresses->addr,
+                         addresses->addrlen),
+                    GNUNET_i2s (&neighbour->id),
+                    addresses->connected,
+                    addresses->in_transmit,
+                    addresses->validated,
+                    addresses->connect_attempts,
+                    (unsigned long long) addresses->timeout.abs_value,
+                    (unsigned int) addresses->distance);
 #endif
-          if (0==strcmp(head->plugin->short_name,"unix"))
-            {
-              if ( (unix_address == NULL) || 
-                   ( (unix_address != NULL) &&
-                     (addresses->latency.rel_value < unix_address->latency.rel_value) ) )
-                unix_address = addresses;
-            }
-          if ( ( (best_address == NULL) ||
-                 (addresses->connected == GNUNET_YES) ||
-                 (best_address->connected == GNUNET_NO) ) &&
-               (addresses->in_transmit == GNUNET_NO) &&
-               ( (best_address == NULL) ||
-                 (addresses->latency.rel_value < best_address->latency.rel_value)) )
-            best_address = addresses;
-          /* FIXME: also give lower-latency addresses that are not
-             connected a chance some times... */
-          addresses = addresses->next;
-        }
-      if (unix_address != NULL)
-          break;
-      head = head->next;
-    }
+      if (0 == strcmp (head->plugin->short_name, "unix"))
+      {
+        if ((unix_address == NULL) ||
+            ((unix_address != NULL) &&
+             (addresses->latency.rel_value < unix_address->latency.rel_value)))
+          unix_address = addresses;
+      }
+      if (((best_address == NULL) ||
+           (addresses->connected == GNUNET_YES) ||
+           (best_address->connected == GNUNET_NO)) &&
+          (addresses->in_transmit == GNUNET_NO) &&
+          ((best_address == NULL) ||
+           (addresses->latency.rel_value < best_address->latency.rel_value)))
+        best_address = addresses;
+      /* FIXME: also give lower-latency addresses that are not
+       * connected a chance some times... */
+      addresses = addresses->next;
+    }
+    if (unix_address != NULL)
+      break;
+    head = head->next;
+  }
   if (unix_address != NULL)
-    {
-      best_address = unix_address;
+  {
+    best_address = unix_address;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Found UNIX address, forced this address\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found UNIX address, forced this address\n");
 #endif
-    }
+  }
   if (best_address != NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Best address found (`%s') has latency of %llu ms.\n",
-                  (best_address->addrlen > 0)
-                  ? a2s (best_address->ready_list->plugin->short_name,
-                         best_address->addr,
-                       best_address->addrlen)
-                  : "<inbound>",
-                  best_address->latency.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Best address found (`%s') has latency of %llu ms.\n",
+                (best_address->addrlen > 0)
+                ? a2s (best_address->ready_list->plugin->short_name,
+                       best_address->addr,
+                       best_address->addrlen)
+                : "<inbound>", best_address->latency.rel_value);
 #endif
-    }
+  }
   else
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# transmission attempts failed (no address)"),
-                                1,
-                                GNUNET_NO);
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# transmission attempts failed (no address)"),
+                              1, GNUNET_NO);
+  }
 
   return best_address;
 }
@@ -2164,15 +2145,15 @@ address_generator (void *cls, size_t max, void *buf)
   size_t ret;
 
   while ((gc->addr_pos == NULL) && (gc->plug_pos != NULL))
-    {
-      gc->plug_pos = gc->plug_pos->next;
-      gc->addr_pos = (gc->plug_pos != NULL) ? gc->plug_pos->addresses : NULL;
-    }
+  {
+    gc->plug_pos = gc->plug_pos->next;
+    gc->addr_pos = (gc->plug_pos != NULL) ? gc->plug_pos->addresses : NULL;
+  }
   if (NULL == gc->plug_pos)
-    {
+  {
 
-      return 0;
-    }
+    return 0;
+  }
   ret = GNUNET_HELLO_add_address (gc->plug_pos->short_name,
                                   gc->expiration,
                                   &gc->addr_pos[1],
@@ -2184,9 +2165,7 @@ address_generator (void *cls, size_t max, void *buf)
 
 
 static int
-transmit_our_hello_if_pong (void *cls,
-                            const GNUNET_HashCode *key,
-                            void *value)
+transmit_our_hello_if_pong (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct NeighbourMapEntry *npos = value;
 
@@ -2194,18 +2173,16 @@ transmit_our_hello_if_pong (void *cls,
     return GNUNET_OK;
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-              "Transmitting updated `%s' to neighbour `%4s'\n",
-              "HELLO", GNUNET_i2s (&npos->id));
+              "Transmitting updated `%s' to neighbour `%4s'\n",
+              "HELLO", GNUNET_i2s (&npos->id));
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# transmitted my HELLO to other peers"),
-                            1,
-                            GNUNET_NO);
-  transmit_to_peer (NULL, NULL, 0,
-                    HELLO_ADDRESS_EXPIRATION,
-                    (const char *) our_hello,
-                    GNUNET_HELLO_size(our_hello),
-                    GNUNET_NO, npos);
+                            gettext_noop
+                            ("# transmitted my HELLO to other peers"), 1,
+                            GNUNET_NO);
+  transmit_to_peer (NULL, NULL, 0, HELLO_ADDRESS_EXPIRATION,
+                    (const char *) our_hello, GNUNET_HELLO_size (our_hello),
+                    GNUNET_NO, npos);
   return GNUNET_OK;
 }
 
@@ -2218,8 +2195,7 @@ transmit_our_hello_if_pong (void *cls,
  * @param tc scheduler context
  */
 static void
-refresh_hello_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+refresh_hello_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_HELLO_Message *hello;
   struct TransportClient *cpos;
@@ -2232,29 +2208,26 @@ refresh_hello_task (void *cls,
   hello = GNUNET_HELLO_create (&my_public_key, &address_generator, &gc);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-              "Refreshed my `%s', new size is %d\n", "HELLO", GNUNET_HELLO_size(hello));
+              "Refreshed my `%s', new size is %d\n", "HELLO",
+              GNUNET_HELLO_size (hello));
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# refreshed my HELLO"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# refreshed my HELLO"),
+                            1, GNUNET_NO);
   cpos = clients;
   while (cpos != NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting my HELLO to client!\n");
-      transmit_to_client (cpos,
-                          (const struct GNUNET_MessageHeader *) hello,
-                          GNUNET_NO);
-      cpos = cpos->next;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting my HELLO to client!\n");
+    transmit_to_client (cpos,
+                        (const struct GNUNET_MessageHeader *) hello, GNUNET_NO);
+    cpos = cpos->next;
+  }
 
   GNUNET_free_non_null (our_hello);
   our_hello = hello;
   GNUNET_PEERINFO_add_peer (peerinfo, our_hello);
   GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &transmit_our_hello_if_pong,
-                                         NULL);
+                                         &transmit_our_hello_if_pong, NULL);
 }
 
 
@@ -2266,14 +2239,11 @@ static void
 refresh_hello ()
 {
 #if DEBUG_TRANSPORT_HELLO
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "refresh_hello() called!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "refresh_hello() called!\n");
 #endif
   if (hello_task != GNUNET_SCHEDULER_NO_TASK)
     return;
-  hello_task
-    = GNUNET_SCHEDULER_add_now (&refresh_hello_task,
-                                NULL);
+  hello_task = GNUNET_SCHEDULER_add_now (&refresh_hello_task, NULL);
 }
 
 
@@ -2287,9 +2257,7 @@ refresh_hello ()
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-remove_session_validations (void *cls,
-                            const GNUNET_HashCode * key,
-                            void *value)
+remove_session_validations (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct Session *session = cls;
   struct ValidationEntry *ve = value;
@@ -2313,34 +2281,32 @@ remove_session_validations (void *cls,
  * @param nl neighbour that was disconnected
  */
 static void
-try_fast_reconnect (struct TransportPlugin *p,
-                    struct NeighbourMapEntry *nl)
+try_fast_reconnect (struct TransportPlugin *p, struct NeighbourMapEntry *nl)
 {
   /* FIXME-MW: fast reconnect / transport switching not implemented... */
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "try_fast_reconnect not implemented!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "try_fast_reconnect not implemented!\n");
   /* Note: the idea here is to hide problems with transports (or
-     switching between plugins) from the core to eliminate the need to
-     re-negotiate session keys and the like; OTOH, we should tell core
-     quickly (much faster than timeout) `if a connection was lost and
-     could not be re-established (i.e. other peer went down or is
-     unable / refuses to communicate);
-
-     So we should consider:
-     1) ideally: our own willingness / need to connect
-     2) prior failures to connect to this peer (by plugin)
-     3) ideally: reasons why other peer terminated (as far as knowable)
-
-     Most importantly, it must be POSSIBLE for another peer to terminate
-     a connection for a while (without us instantly re-establishing it).
-     Similarly, if another peer is gone we should quickly notify CORE.
-     OTOH, if there was a minor glitch (i.e. crash of gnunet-service-transport
-     on the other end), we should reconnect in such a way that BOTH CORE
-     services never even notice.
-     Furthermore, the same mechanism (or small variation) could be used
-     to switch to a better-performing plugin (ATS).
-
-     Finally, this needs to be tested throughly... */
+   * switching between plugins) from the core to eliminate the need to
+   * re-negotiate session keys and the like; OTOH, we should tell core
+   * quickly (much faster than timeout) `if a connection was lost and
+   * could not be re-established (i.e. other peer went down or is
+   * unable / refuses to communicate);
+   * 
+   * So we should consider:
+   * 1) ideally: our own willingness / need to connect
+   * 2) prior failures to connect to this peer (by plugin)
+   * 3) ideally: reasons why other peer terminated (as far as knowable)
+   * 
+   * Most importantly, it must be POSSIBLE for another peer to terminate
+   * a connection for a while (without us instantly re-establishing it).
+   * Similarly, if another peer is gone we should quickly notify CORE.
+   * OTOH, if there was a minor glitch (i.e. crash of gnunet-service-transport
+   * on the other end), we should reconnect in such a way that BOTH CORE
+   * services never even notice.
+   * Furthermore, the same mechanism (or small variation) could be used
+   * to switch to a better-performing plugin (ATS).
+   * 
+   * Finally, this needs to be tested throughly... */
 
   /*
    * GNUNET_NO in the call below makes transport disconnect the peer,
@@ -2355,12 +2321,12 @@ try_fast_reconnect (struct TransportPlugin *p,
 #if DEBUG_TRANSPORT
 #endif
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-            "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&nl->id),
-            "try_fast_reconnect");
+              "Disconnecting peer `%4s', %s\n", GNUNET_i2s (&nl->id),
+              "try_fast_reconnect");
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# disconnects due to try_fast_reconnect"),
-                            1,
+                            gettext_noop
+                            ("# disconnects due to try_fast_reconnect"), 1,
                             GNUNET_NO);
 #if DISCONNECT || 1
   disconnect_neighbour (nl, GNUNET_YES);
@@ -2380,9 +2346,9 @@ try_fast_reconnect (struct TransportPlugin *p,
  * @param session which session is being destoyed
  */
 static void
-plugin_env_session_end  (void *cls,
-                         const struct GNUNET_PeerIdentity *peer,
-                         struct Session *session)
+plugin_env_session_end (void *cls,
+                        const struct GNUNET_PeerIdentity *peer,
+                        struct Session *session)
 {
   struct TransportPlugin *p = cls;
   struct NeighbourMapEntry *nl;
@@ -2392,119 +2358,116 @@ plugin_env_session_end  (void *cls,
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Session ended with peer `%4s', %s\n", 
-              GNUNET_i2s(peer),
-              "plugin_env_session_end");
+              "Session ended with peer `%4s', %s\n",
+              GNUNET_i2s (peer), "plugin_env_session_end");
 #endif
   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
-                                         &remove_session_validations,
-                                         session);
+                                         &remove_session_validations, session);
   nl = find_neighbour (peer);
   if (nl == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No neighbour record found for peer `%4s'\n", 
-                  GNUNET_i2s(peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No neighbour record found for peer `%4s'\n",
+                GNUNET_i2s (peer));
 #endif
-      return; /* was never marked as connected */
-    }
+    return;                     /* was never marked as connected */
+  }
   rl = nl->plugins;
   while (rl != NULL)
-    {
-      if (rl->plugin == p)
-        break;
-      rl = rl->next;
-    }
+  {
+    if (rl->plugin == p)
+      break;
+    rl = rl->next;
+  }
   if (rl == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Plugin was associated with peer `%4s'\n", 
-                  GNUNET_i2s(peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Plugin was associated with peer `%4s'\n", GNUNET_i2s (peer));
 #endif
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# disconnects due to session end"),
-                                1,
-                                GNUNET_NO);
-      disconnect_neighbour (nl, GNUNET_YES);
-      return;
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# disconnects due to session end"),
+                              1, GNUNET_NO);
+    disconnect_neighbour (nl, GNUNET_YES);
+    return;
+  }
   prev = NULL;
   pos = rl->addresses;
-  while ( (pos != NULL) &&
-          (pos->session != session) )
-    {
-      prev = pos;
-      pos = pos->next;
-    }
+  while ((pos != NULL) && (pos->session != session))
+  {
+    prev = pos;
+    pos = pos->next;
+  }
   if (pos == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Session was never marked as ready for peer `%4s'\n", 
-                  GNUNET_i2s(peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Session was never marked as ready for peer `%4s'\n",
+                GNUNET_i2s (peer));
 #endif
 
-      int validations_pending = GNUNET_CONTAINER_multihashmap_contains (validation_map, &peer->hashPubKey);
+    int validations_pending =
+        GNUNET_CONTAINER_multihashmap_contains (validation_map,
+                                                &peer->hashPubKey);
 
-      /* No session was marked as ready, but we have pending validations so do not disconnect from neighbour */
-      if (validations_pending ==GNUNET_YES)
-        {
+    /* No session was marked as ready, but we have pending validations so do not disconnect from neighbour */
+    if (validations_pending == GNUNET_YES)
+    {
 #if DEBUG_TRANSPORT
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Not disconnecting from peer `%4s due to pending address validations\n", GNUNET_i2s(peer));
+                  "Not disconnecting from peer `%4s due to pending address validations\n",
+                  GNUNET_i2s (peer));
 #endif
-        return;
-        }
+      return;
+    }
 
-      //FIXME: This conflicts with inbound tcp connections and tcp nat ... debugging in progress
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# disconnects due to unready session"),
-                                1,
-                                GNUNET_NO);
+    //FIXME: This conflicts with inbound tcp connections and tcp nat ... debugging in progress
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# disconnects due to unready session"), 1,
+                              GNUNET_NO);
 
-      disconnect_neighbour (nl, GNUNET_YES);
-      return; /* was never marked as connected */
-    }
+    disconnect_neighbour (nl, GNUNET_YES);
+    return;                     /* was never marked as connected */
+  }
   pos->session = NULL;
   if (GNUNET_YES == pos->connected)
-    {
-      pos->connected = GNUNET_NO;      
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# connected addresses"),
-                                -1,
-                                GNUNET_NO);
-    }
+  {
+    pos->connected = GNUNET_NO;
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# connected addresses"),
+                              -1, GNUNET_NO);
+  }
   if (GNUNET_SCHEDULER_NO_TASK != pos->revalidate_task)
-    {
-      GNUNET_SCHEDULER_cancel (pos->revalidate_task);
-      pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pos->revalidate_task);
+    pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
+  }
 
   if (pos->addrlen != 0)
+  {
+    if (nl->received_pong != GNUNET_NO)
     {
-      if (nl->received_pong != GNUNET_NO)
-        {
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# try_fast_reconnect thanks to plugin_env_session_end"),
-                                    1,
-                                    GNUNET_NO);
-          if (GNUNET_YES == pos->connected)                  
-              try_fast_reconnect (p, nl);           
-        }
-      else
-        {
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# disconnects due to missing pong"),
-                                    1,
-                                    GNUNET_NO);
-          /* FIXME this is never true?! See: line 2416*/
-          if (GNUNET_YES == pos->connected)
-            disconnect_neighbour (nl, GNUNET_YES);
-        }
-      return;
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# try_fast_reconnect thanks to plugin_env_session_end"),
+                                1, GNUNET_NO);
+      if (GNUNET_YES == pos->connected)
+        try_fast_reconnect (p, nl);
     }
+    else
+    {
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# disconnects due to missing pong"), 1,
+                                GNUNET_NO);
+      /* FIXME this is never true?! See: line 2416 */
+      if (GNUNET_YES == pos->connected)
+        disconnect_neighbour (nl, GNUNET_YES);
+    }
+    return;
+  }
 
   /* was inbound connection, free 'pos' */
   if (prev == NULL)
@@ -2512,59 +2475,56 @@ plugin_env_session_end  (void *cls,
   else
     prev->next = pos->next;
   if (GNUNET_SCHEDULER_NO_TASK != pos->revalidate_task)
-    {
-      GNUNET_SCHEDULER_cancel (pos->revalidate_task);
-      pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pos->revalidate_task);
+    pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_free_non_null (pos->ressources);
   GNUNET_free_non_null (pos->quality);
 #if HAVE_LIBGLPK
   ats_modify_problem_state (ats, ATS_MODIFIED);
 #endif
   if (GNUNET_YES != pos->connected)
-    {
-      /* nothing else to do, connection was never up... */
-      GNUNET_free (pos);
-      return; 
-    }
+  {
+    /* nothing else to do, connection was never up... */
+    GNUNET_free (pos);
+    return;
+  }
   pos->connected = GNUNET_NO;
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# connected addresses"),
-                            -1,
-                            GNUNET_NO);
+                            gettext_noop ("# connected addresses"),
+                            -1, GNUNET_NO);
   GNUNET_free (pos);
 
   if (nl->received_pong == GNUNET_NO)
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# disconnects due to NO pong"),
-                                1,
-                                GNUNET_NO);
-      disconnect_neighbour (nl, GNUNET_YES);
-      return; /* nothing to do, never connected... */
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# disconnects due to NO pong"),
+                              1, GNUNET_NO);
+    disconnect_neighbour (nl, GNUNET_YES);
+    return;                     /* nothing to do, never connected... */
+  }
   /* check if we have any validated addresses left */
   pos = rl->addresses;
   while (pos != NULL)
+  {
+    if (GNUNET_YES == pos->validated)
     {
-      if (GNUNET_YES == pos->validated)
-        {
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# try_fast_reconnect thanks to validated_address"),
-                                    1,
-                                    GNUNET_NO);
-          try_fast_reconnect (p, nl);
-          return;
-        }
-      pos = pos->next;
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# try_fast_reconnect thanks to validated_address"),
+                                1, GNUNET_NO);
+      try_fast_reconnect (p, nl);
+      return;
     }
+    pos = pos->next;
+  }
   /* no valid addresses left, signal disconnect! */
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting peer `%4s', %s\n", 
-              GNUNET_i2s(peer),
-              "plugin_env_session_end");
+              "Disconnecting peer `%4s', %s\n",
+              GNUNET_i2s (peer), "plugin_env_session_end");
 #endif
   /* FIXME: This doesn't mean there are no addresses left for this PEER,
    * it means there aren't any left for this PLUGIN/PEER combination! So
@@ -2574,8 +2534,8 @@ plugin_env_session_end  (void *cls,
    * --NE
    */
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# disconnects due to plugin_env_session_end"),
-                            1,
+                            gettext_noop
+                            ("# disconnects due to plugin_env_session_end"), 1,
                             GNUNET_NO);
   disconnect_neighbour (nl, GNUNET_YES);
 }
@@ -2594,9 +2554,7 @@ plugin_env_session_end  (void *cls,
  */
 static void
 plugin_env_notify_address (void *cls,
-                           int add_remove,
-                           const void *addr,
-                           size_t addrlen)
+                           int add_remove, const void *addr, size_t addrlen)
 {
   struct TransportPlugin *p = cls;
   struct OwnAddressList *al;
@@ -2605,37 +2563,34 @@ plugin_env_notify_address (void *cls,
   GNUNET_assert (p->api != NULL);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              (add_remove == GNUNET_YES)
-              ? "Adding `%s':%s to the set of our addresses\n"
-              : "Removing `%s':%s from the set of our addresses\n",
-              a2s (p->short_name,
-                   addr, addrlen),
-              p->short_name);
+              (add_remove == GNUNET_YES)
+              ? "Adding `%s':%s to the set of our addresses\n"
+              : "Removing `%s':%s from the set of our addresses\n",
+              a2s (p->short_name, addr, addrlen), p->short_name);
 #endif
   GNUNET_assert (addr != NULL);
   if (GNUNET_NO == add_remove)
+  {
+    prev = NULL;
+    al = p->addresses;
+    while (al != NULL)
     {
-      prev = NULL;
-      al = p->addresses;
-      while (al != NULL)
-        {
-          if ( (addrlen == al->addrlen) &&
-               (0 == memcmp (addr, &al[1], addrlen)) )
-            {
-              if (prev == NULL)
-                p->addresses = al->next;
-              else
-                prev->next = al->next;
-              GNUNET_free (al);
-              refresh_hello ();
-              return;
-            }
-          prev = al;
-          al = al->next;
-        }
-      GNUNET_break (0);
-      return;
+      if ((addrlen == al->addrlen) && (0 == memcmp (addr, &al[1], addrlen)))
+      {
+        if (prev == NULL)
+          p->addresses = al->next;
+        else
+          prev->next = al->next;
+        GNUNET_free (al);
+        refresh_hello ();
+        return;
+      }
+      prev = al;
+      al = al->next;
     }
+    GNUNET_break (0);
+    return;
+  }
   al = GNUNET_malloc (sizeof (struct OwnAddressList) + addrlen);
   al->next = p->addresses;
   p->addresses = al;
@@ -2650,38 +2605,35 @@ plugin_env_notify_address (void *cls,
  */
 static void
 notify_clients_connect (const struct GNUNET_PeerIdentity *peer,
-                        struct GNUNET_TIME_Relative latency,
-                        uint32_t distance)
+                        struct GNUNET_TIME_Relative latency, uint32_t distance)
 {
-  struct ConnectInfoMessage * cim;
+  struct ConnectInfoMessage *cim;
   struct TransportClient *cpos;
   uint32_t ats_count;
   size_t size;
 
-  if (0 == memcmp (peer,
-                   &my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_break (0);
+    return;
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Notifying clients about connection with `%s'\n",
-              GNUNET_i2s (peer));
+              "Notifying clients about connection with `%s'\n",
+              GNUNET_i2s (peer));
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# peers connected"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# peers connected"), 1, GNUNET_NO);
 
   ats_count = 2;
-  size  = sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+  size =
+      sizeof (struct ConnectInfoMessage) +
+      ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
   GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   cim = GNUNET_malloc (size);
   cim->header.size = htons (size);
   cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
-  cim->ats_count = htonl(2);
+  cim->ats_count = htonl (2);
   (&cim->ats)[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
   (&cim->ats)[0].value = htonl (distance);
   (&cim->ats)[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
@@ -2692,18 +2644,18 @@ notify_clients_connect (const struct GNUNET_PeerIdentity *peer,
 
   /* notify ats about connecting peer */
   if ((ats != NULL) && (shutdown_in_progress == GNUNET_NO))
-    {
+  {
 #if HAVE_LIBGLPK
-      ats_modify_problem_state(ats, ATS_MODIFIED);
-      ats_calculate_bandwidth_distribution (ats);
+    ats_modify_problem_state (ats, ATS_MODIFIED);
+    ats_calculate_bandwidth_distribution (ats);
 #endif
-    }
+  }
   cpos = clients;
   while (cpos != NULL)
-    {
-      transmit_to_client (cpos, &cim->header, GNUNET_NO);
-      cpos = cpos->next;
-    }
+  {
+    transmit_to_client (cpos, &cim->header, GNUNET_NO);
+    cpos = cpos->next;
+  }
   GNUNET_free (cim);
 }
 
@@ -2717,22 +2669,18 @@ notify_clients_disconnect (const struct GNUNET_PeerIdentity *peer)
   struct DisconnectInfoMessage dim;
   struct TransportClient *cpos;
 
-  if (0 == memcmp (peer,
-                   &my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_break (0);
+    return;
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Notifying clients about lost connection to `%s'\n",
-              GNUNET_i2s (peer));
+              "Notifying clients about lost connection to `%s'\n",
+              GNUNET_i2s (peer));
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# peers connected"),
-                            -1,
-                            GNUNET_NO);
+                            gettext_noop ("# peers connected"), -1, GNUNET_NO);
   dim.header.size = htons (sizeof (struct DisconnectInfoMessage));
   dim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
   dim.reserved = htonl (0);
@@ -2742,17 +2690,17 @@ notify_clients_disconnect (const struct GNUNET_PeerIdentity *peer)
   if ((ats != NULL) && (shutdown_in_progress == GNUNET_NO))
   {
 #if HAVE_LIBGLPK
-    ats_modify_problem_state(ats, ATS_MODIFIED);
+    ats_modify_problem_state (ats, ATS_MODIFIED);
     ats_calculate_bandwidth_distribution (ats);
 #endif
   }
 
   cpos = clients;
   while (cpos != NULL)
-    {
-      transmit_to_client (cpos, &dim.header, GNUNET_NO);
-      cpos = cpos->next;
-    }
+  {
+    transmit_to_client (cpos, &dim.header, GNUNET_NO);
+    cpos = cpos->next;
+  }
 }
 
 
@@ -2770,36 +2718,33 @@ notify_clients_disconnect (const struct GNUNET_PeerIdentity *peer)
  * @return NULL if no such entry exists
  */
 static struct ForeignAddressList *
-find_peer_address(struct NeighbourMapEntry *neighbour,
-                  const char *tname,
-                  struct Session *session,
-                  const char *addr,
-                  uint16_t addrlen)
+find_peer_address (struct NeighbourMapEntry *neighbour,
+                   const char *tname,
+                   struct Session *session, const char *addr, uint16_t addrlen)
 {
   struct ReadyList *head;
   struct ForeignAddressList *pos;
 
   head = neighbour->plugins;
   while (head != NULL)
-    {
-      if (0 == strcmp (tname, head->plugin->short_name))
-        break;
-      head = head->next;
-    }
+  {
+    if (0 == strcmp (tname, head->plugin->short_name))
+      break;
+    head = head->next;
+  }
   if (head == NULL)
     return NULL;
   pos = head->addresses;
-  while ( (pos != NULL) &&
-          ( (pos->addrlen != addrlen) ||
-            (memcmp(pos->addr, addr, addrlen) != 0) ) )
-    {
-      if ( (session != NULL) &&
-           (pos->session == session) )
-        return pos;
-      pos = pos->next;
-    }
-  if ( (session != NULL) && (pos != NULL) )
-    pos->session = session; /* learn it! */
+  while ((pos != NULL) &&
+         ((pos->addrlen != addrlen) ||
+          (memcmp (pos->addr, addr, addrlen) != 0)))
+  {
+    if ((session != NULL) && (pos->session == session))
+      return pos;
+    pos = pos->next;
+  }
+  if ((session != NULL) && (pos != NULL))
+    pos->session = session;     /* learn it! */
   return pos;
 }
 
@@ -2817,10 +2762,8 @@ find_peer_address(struct NeighbourMapEntry *neighbour,
  */
 static struct ForeignAddressList *
 add_peer_address (struct NeighbourMapEntry *neighbour,
-                  const char *tname,
-                  struct Session *session,
-                  const char *addr,
-                  uint16_t addrlen)
+                  const char *tname,
+                  struct Session *session, const char *addr, uint16_t addrlen)
 {
   struct ReadyList *head;
   struct ForeignAddressList *ret;
@@ -2832,73 +2775,78 @@ add_peer_address (struct NeighbourMapEntry *neighbour,
   head = neighbour->plugins;
 
   while (head != NULL)
-    {
-      if (0 == strcmp (tname, head->plugin->short_name))
-        break;
-      head = head->next;
-    }
+  {
+    if (0 == strcmp (tname, head->plugin->short_name))
+      break;
+    head = head->next;
+  }
   if (head == NULL)
     return NULL;
-  ret = GNUNET_malloc(sizeof(struct ForeignAddressList) + addrlen);
+  ret = GNUNET_malloc (sizeof (struct ForeignAddressList) + addrlen);
   ret->session = session;
   if ((addrlen > 0) && (addr != NULL))
+  {
+    ret->addr = (const char *) &ret[1];
+    memcpy (&ret[1], addr, addrlen);
+  }
+  else
+  {
+    ret->addr = NULL;
+  }
+
+  ret->ressources =
+      GNUNET_malloc (available_ressources *
+                     sizeof (struct ATS_ressource_entry));
+  for (c = 0; c < available_ressources; c++)
+  {
+    struct ATS_ressource_entry *r = ret->ressources;
+
+    r[c].index = c;
+    r[c].atis_index = ressources[c].atis_index;
+    if (0 == strcmp (neighbour->plugins->plugin->short_name, "unix"))
     {
-      ret->addr = (const char*) &ret[1];
-      memcpy (&ret[1], addr, addrlen);
+      r[c].c = ressources[c].c_unix;
     }
-  else
+    else if (0 == strcmp (neighbour->plugins->plugin->short_name, "udp"))
     {
-      ret->addr = NULL;
+      r[c].c = ressources[c].c_udp;
     }
-
-  ret->ressources = GNUNET_malloc(available_ressources * sizeof (struct ATS_ressource_entry));
-  for (c=0; c<available_ressources; c++)
+    else if (0 == strcmp (neighbour->plugins->plugin->short_name, "tcp"))
     {
-      struct ATS_ressource_entry *r = ret->ressources;
-      r[c].index = c;
-      r[c].atis_index = ressources[c].atis_index;
-      if (0 == strcmp(neighbour->plugins->plugin->short_name,"unix"))
-        {
-          r[c].c = ressources[c].c_unix;
-        }
-      else if (0 == strcmp(neighbour->plugins->plugin->short_name,"udp"))
-        {
-          r[c].c = ressources[c].c_udp;
-        }
-      else if (0 == strcmp(neighbour->plugins->plugin->short_name,"tcp"))
-        {
-          r[c].c = ressources[c].c_tcp;
-        }
-      else if (0 == strcmp(neighbour->plugins->plugin->short_name,"http"))
-        {
-          r[c].c = ressources[c].c_http;
-        }
-      else if (0 == strcmp(neighbour->plugins->plugin->short_name,"https"))
-        {
-          r[c].c = ressources[c].c_https;
-        }
-      else if (0 == strcmp(neighbour->plugins->plugin->short_name,"wlan"))
-        {
-          r[c].c = ressources[c].c_wlan;
-        }
-      else
-        {
-          r[c].c = ressources[c].c_default;
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      "Assigning default cost to peer `%s' addr plugin `%s'! This should not happen!\n",
-                      GNUNET_i2s(&neighbour->id),
-                      neighbour->plugins->plugin->short_name);
-        }
+      r[c].c = ressources[c].c_tcp;
+    }
+    else if (0 == strcmp (neighbour->plugins->plugin->short_name, "http"))
+    {
+      r[c].c = ressources[c].c_http;
+    }
+    else if (0 == strcmp (neighbour->plugins->plugin->short_name, "https"))
+    {
+      r[c].c = ressources[c].c_https;
     }
+    else if (0 == strcmp (neighbour->plugins->plugin->short_name, "wlan"))
+    {
+      r[c].c = ressources[c].c_wlan;
+    }
+    else
+    {
+      r[c].c = ressources[c].c_default;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Assigning default cost to peer `%s' addr plugin `%s'! This should not happen!\n",
+                  GNUNET_i2s (&neighbour->id),
+                  neighbour->plugins->plugin->short_name);
+    }
+  }
 
-  ret->quality = GNUNET_malloc (available_quality_metrics * sizeof (struct ATS_quality_entry));
+  ret->quality =
+      GNUNET_malloc (available_quality_metrics *
+                     sizeof (struct ATS_quality_entry));
   ret->addrlen = addrlen;
   ret->expires = GNUNET_TIME_relative_to_absolute
-    (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
-  ret->latency = GNUNET_TIME_relative_get_forever();
+      (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  ret->latency = GNUNET_TIME_relative_get_forever ();
   ret->distance = -1;
   ret->timeout = GNUNET_TIME_relative_to_absolute
-    (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+      (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
   ret->ready_list = head;
   ret->next = head->addresses;
   head->addresses = ret;
@@ -2936,8 +2884,7 @@ struct AddValidatedAddressContext
  *         end of the iteration.
  */
 static size_t
-add_validated_address (void *cls,
-                       size_t max, void *buf)
+add_validated_address (void *cls, size_t max, void *buf)
 {
   struct AddValidatedAddressContext *avac = cls;
   const struct ValidationEntry *ve = avac->ve;
@@ -2946,11 +2893,9 @@ add_validated_address (void *cls,
     return 0;
   avac->done = GNUNET_YES;
   return GNUNET_HELLO_add_address (ve->transport_name,
-                                   GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION),
-                                   ve->addr,
-                                   ve->addrlen,
-                                   buf,
-                                   max);
+                                   GNUNET_TIME_relative_to_absolute
+                                   (HELLO_ADDRESS_EXPIRATION), ve->addr,
+                                   ve->addrlen, buf, max);
 }
 
 
@@ -3000,36 +2945,31 @@ struct CheckAddressExistsClosure
  *         iterate (mismatch), GNUNET_NO if not (entry matched)
  */
 static int
-check_address_exists (void *cls,
-                      const GNUNET_HashCode * key,
-                      void *value)
+check_address_exists (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct CheckAddressExistsClosure *caec = cls;
   struct ValidationEntry *ve = value;
 
-  if ( (0 == strcmp (caec->tname,
-                     ve->transport_name)) &&
-       (caec->addrlen == ve->addrlen) &&
-       (0 == memcmp (caec->addr,
-                     ve->addr,
-                     caec->addrlen)) )
-    {
-      caec->exists = GNUNET_YES;
-      return GNUNET_NO;
-    }
-  if ( (ve->session != NULL) &&
-       (caec->session == ve->session) )
-    {
-      caec->exists = GNUNET_YES;
-      return GNUNET_NO;
-    }
+  if ((0 == strcmp (caec->tname,
+                    ve->transport_name)) &&
+      (caec->addrlen == ve->addrlen) &&
+      (0 == memcmp (caec->addr, ve->addr, caec->addrlen)))
+  {
+    caec->exists = GNUNET_YES;
+    return GNUNET_NO;
+  }
+  if ((ve->session != NULL) && (caec->session == ve->session))
+  {
+    caec->exists = GNUNET_YES;
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
 
 static void
 neighbour_timeout_task (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+                        const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct NeighbourMapEntry *n = cls;
 
@@ -3038,9 +2978,8 @@ neighbour_timeout_task (void *cls,
               "Neighbour `%4s' has timed out!\n", GNUNET_i2s (&n->id));
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# disconnects due to timeout"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# disconnects due to timeout"),
+                            1, GNUNET_NO);
   n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   disconnect_neighbour (n, GNUNET_NO);
 }
@@ -3052,8 +2991,7 @@ neighbour_timeout_task (void *cls,
  *
  * @param fal address to PING
  */
-static void
-schedule_next_ping (struct ForeignAddressList *fal);
+static void schedule_next_ping (struct ForeignAddressList *fal);
 
 
 /**
@@ -3069,77 +3007,71 @@ schedule_next_ping (struct ForeignAddressList *fal);
  */
 static int
 add_to_foreign_address_list (void *cls,
-                             const char *tname,
-                             struct GNUNET_TIME_Absolute expiration,
-                             const void *addr,
-                             uint16_t addrlen)
+                             const char *tname,
+                             struct GNUNET_TIME_Absolute expiration,
+                             const void *addr, uint16_t addrlen)
 {
   struct NeighbourMapEntry *n = cls;
   struct ForeignAddressList *fal;
   int try;
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# valid peer addresses returned by PEERINFO"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# valid peer addresses returned by PEERINFO"), 1,
+                            GNUNET_NO);
   try = GNUNET_NO;
   fal = find_peer_address (n, tname, NULL, addr, addrlen);
   if (fal == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT_HELLO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Adding address `%s' (%s) for peer `%4s' due to PEERINFO data for %llums.\n",
-                  a2s (tname, addr, addrlen),
-                  tname,
-                  GNUNET_i2s (&n->id),
-                  expiration.abs_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Adding address `%s' (%s) for peer `%4s' due to PEERINFO data for %llums.\n",
+                a2s (tname, addr, addrlen),
+                tname, GNUNET_i2s (&n->id), expiration.abs_value);
 #endif
-      fal = add_peer_address (n, tname, NULL, addr, addrlen);
-      if (fal == NULL)
-        {
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# previously validated addresses lacking transport"),
-                                    1,
-                                    GNUNET_NO);
-        }
-      else
-        {
-          fal->expires = GNUNET_TIME_absolute_max (expiration,
-                                                   fal->expires);
-          schedule_next_ping (fal);
-        }
-      try = GNUNET_YES;
+    fal = add_peer_address (n, tname, NULL, addr, addrlen);
+    if (fal == NULL)
+    {
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# previously validated addresses lacking transport"),
+                                1, GNUNET_NO);
     }
-  else
+    else
     {
-      fal->expires = GNUNET_TIME_absolute_max (expiration,
-                                               fal->expires);
+      fal->expires = GNUNET_TIME_absolute_max (expiration, fal->expires);
+      schedule_next_ping (fal);
     }
+    try = GNUNET_YES;
+  }
+  else
+  {
+    fal->expires = GNUNET_TIME_absolute_max (expiration, fal->expires);
+  }
   if (fal == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Failed to add new address for `%4s'\n",
-                  GNUNET_i2s (&n->id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to add new address for `%4s'\n", GNUNET_i2s (&n->id));
 #endif
-      return GNUNET_OK;
-    }
+    return GNUNET_OK;
+  }
   if (fal->validated == GNUNET_NO)
-    {
-      fal->validated = GNUNET_YES;
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# peer addresses considered valid"),
-                                1,
-                                GNUNET_NO);
-    }
+  {
+    fal->validated = GNUNET_YES;
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# peer addresses considered valid"), 1,
+                              GNUNET_NO);
+  }
   if (try == GNUNET_YES)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Have new addresses, will try to trigger transmissions.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Have new addresses, will try to trigger transmissions.\n");
 #endif
-      try_transmission_to_peer (n);
-    }
+    try_transmission_to_peer (n);
+  }
   return GNUNET_OK;
 }
 
@@ -3155,47 +3087,43 @@ add_to_foreign_address_list (void *cls,
  */
 static void
 add_hello_for_peer (void *cls,
-                    const struct GNUNET_PeerIdentity *peer,
-                    const struct GNUNET_HELLO_Message *h,
-                    const char *err_msg)
+                    const struct GNUNET_PeerIdentity *peer,
+                    const struct GNUNET_HELLO_Message *h, const char *err_msg)
 {
   struct NeighbourMapEntry *n = cls;
 
   if (err_msg != NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Error in communication with PEERINFO service: %s\n"),
-                  err_msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Error in communication with PEERINFO service: %s\n"),
+                err_msg);
 #endif
-      /* return; */
-    }
+    /* return; */
+  }
   if (peer == NULL)
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# outstanding peerinfo iterate requests"),
-                                -1,
-                                GNUNET_NO);
-      n->piter = NULL;
-      return;
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# outstanding peerinfo iterate requests"), -1,
+                              GNUNET_NO);
+    n->piter = NULL;
+    return;
+  }
   if (h == NULL)
-    return; /* no HELLO available */
+    return;                     /* no HELLO available */
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peerinfo had `%s' message for peer `%4s', adding existing addresses.\n",
-              "HELLO",
-              GNUNET_i2s (peer));
+              "Peerinfo had `%s' message for peer `%4s', adding existing addresses.\n",
+              "HELLO", GNUNET_i2s (peer));
 #endif
   if (GNUNET_YES != n->public_key_valid)
-    {
-      GNUNET_HELLO_get_key (h, &n->publicKey);
-      n->public_key_valid = GNUNET_YES;
-    }
+  {
+    GNUNET_HELLO_get_key (h, &n->publicKey);
+    n->public_key_valid = GNUNET_YES;
+  }
   GNUNET_HELLO_iterate_addresses (h,
-                                  GNUNET_NO,
-                                  &add_to_foreign_address_list,
-                                  n);
+                                  GNUNET_NO, &add_to_foreign_address_list, n);
 }
 
 
@@ -3209,79 +3137,73 @@ add_hello_for_peer (void *cls,
  * @return the new neighbour list entry
  */
 static struct NeighbourMapEntry *
-setup_new_neighbour (const struct GNUNET_PeerIdentity *peer,
-                     int do_hello)
+setup_new_neighbour (const struct GNUNET_PeerIdentity *peer, int do_hello)
 {
   struct NeighbourMapEntry *n;
   struct TransportPlugin *tp;
   struct ReadyList *rl;
 
   GNUNET_assert (0 != memcmp (peer,
-                              &my_identity,
-                              sizeof (struct GNUNET_PeerIdentity)));
+                              &my_identity,
+                              sizeof (struct GNUNET_PeerIdentity)));
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Setting up state for neighbour `%4s'\n",
-              GNUNET_i2s (peer));
+              "Setting up state for neighbour `%4s'\n", GNUNET_i2s (peer));
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# active neighbours"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# active neighbours"), 1, GNUNET_NO);
   n = GNUNET_malloc (sizeof (struct NeighbourMapEntry));
   n->id = *peer;
   n->peer_timeout =
-    GNUNET_TIME_relative_to_absolute
-    (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+      GNUNET_TIME_relative_to_absolute
+      (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
   GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
-                                 GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
-                                 MAX_BANDWIDTH_CARRY_S);
+                                 GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
+                                 MAX_BANDWIDTH_CARRY_S);
   tp = plugins;
   while (tp != NULL)
+  {
+    if ((tp->api->send != NULL) && (!is_blacklisted (peer, tp)))
     {
-      if ((tp->api->send != NULL) && (!is_blacklisted(peer, tp)))
-        {
-          rl = GNUNET_malloc (sizeof (struct ReadyList));
-          rl->neighbour = n;
-          rl->next = n->plugins;
-          n->plugins = rl;
-          rl->plugin = tp;
-          rl->addresses = NULL;
-        }
-      tp = tp->next;
+      rl = GNUNET_malloc (sizeof (struct ReadyList));
+      rl->neighbour = n;
+      rl->next = n->plugins;
+      n->plugins = rl;
+      rl->plugin = tp;
+      rl->addresses = NULL;
     }
+    tp = tp->next;
+  }
   n->latency = GNUNET_TIME_UNIT_FOREVER_REL;
   n->distance = -1;
-  n->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                                                  &neighbour_timeout_task, n);
-  GNUNET_CONTAINER_multihashmap_put (neighbours,
-                                     &n->id.hashPubKey,
-                                     n,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  n->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                    &neighbour_timeout_task, n);
+  GNUNET_CONTAINER_multihashmap_put (neighbours, &n->id.hashPubKey, n,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
   if (do_hello)
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# peerinfo new neighbor iterate requests"),
-                                1,
-                                GNUNET_NO);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# outstanding peerinfo iterate requests"),
-                                1,
-                                GNUNET_NO);
-      n->piter = GNUNET_PEERINFO_iterate (peerinfo, peer,
-                                          GNUNET_TIME_UNIT_FOREVER_REL,
-                                          &add_hello_for_peer, n);
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# peerinfo new neighbor iterate requests"), 1,
+                              GNUNET_NO);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# outstanding peerinfo iterate requests"), 1,
+                              GNUNET_NO);
+    n->piter =
+        GNUNET_PEERINFO_iterate (peerinfo, peer, GNUNET_TIME_UNIT_FOREVER_REL,
+                                 &add_hello_for_peer, n);
 
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# HELLO's sent to new neighbors"),
-                                1,
-                                GNUNET_NO);
-      if (NULL != our_hello)
-        transmit_to_peer (NULL, NULL, 0,
-                          HELLO_ADDRESS_EXPIRATION,
-                          (const char *) our_hello, GNUNET_HELLO_size(our_hello),
-                          GNUNET_NO, n);
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# HELLO's sent to new neighbors"),
+                              1, GNUNET_NO);
+    if (NULL != our_hello)
+      transmit_to_peer (NULL, NULL, 0,
+                        HELLO_ADDRESS_EXPIRATION,
+                        (const char *) our_hello, GNUNET_HELLO_size (our_hello),
+                        GNUNET_NO, n);
+  }
   return n;
 }
 
@@ -3293,8 +3215,7 @@ setup_new_neighbour (const struct GNUNET_PeerIdentity *peer,
  * @param cls closure
  * @param n NULL if communication is not acceptable
  */
-typedef void (*SetupContinuation)(void *cls,
-                                  struct NeighbourMapEntry *n);
+typedef void (*SetupContinuation) (void *cls, struct NeighbourMapEntry * n);
 
 
 /**
@@ -3409,8 +3330,7 @@ static struct BlacklistCheck *bc_tail;
  * @param tc unused
  */
 static void
-do_blacklist_check (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc);
+do_blacklist_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 /**
  * Transmit blacklist query to the client.
@@ -3421,9 +3341,7 @@ do_blacklist_check (void *cls,
  * @return number of bytes copied to buf
  */
 static size_t
-transmit_blacklist_message (void *cls,
-                            size_t size,
-                            void *buf)
+transmit_blacklist_message (void *cls, size_t size, void *buf)
 {
   struct BlacklistCheck *bc = cls;
   struct Blacklisters *bl;
@@ -3431,19 +3349,18 @@ transmit_blacklist_message (void *cls,
 
   bc->th = NULL;
   if (size == 0)
-    {
-      GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
-      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                           bc);
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Failed to send blacklist test for peer `%s' to client\n",
-                  GNUNET_i2s (&bc->peer));
-      return 0;
-    }
+  {
+    GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
+    bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to send blacklist test for peer `%s' to client\n",
+                GNUNET_i2s (&bc->peer));
+    return 0;
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending blacklist test for peer `%s' to client\n",
-              GNUNET_i2s (&bc->peer));
+              "Sending blacklist test for peer `%s' to client\n",
+              GNUNET_i2s (&bc->peer));
 #endif
   bl = bc->bl_pos;
   bm.header.size = htons (sizeof (struct BlacklistMessage));
@@ -3463,8 +3380,7 @@ transmit_blacklist_message (void *cls,
  * @param tc unused
  */
 static void
-do_blacklist_check (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_blacklist_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct BlacklistCheck *bc = cls;
   struct Blacklisters *bl;
@@ -3472,26 +3388,26 @@ do_blacklist_check (void *cls,
   bc->task = GNUNET_SCHEDULER_NO_TASK;
   bl = bc->bl_pos;
   if (bl == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No blacklist clients active, will now setup neighbour record for peer `%s'\n",
-                  GNUNET_i2s (&bc->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No blacklist clients active, will now setup neighbour record for peer `%s'\n",
+                GNUNET_i2s (&bc->peer));
 #endif
-      bc->cont (bc->cont_cls,
-                setup_new_neighbour (&bc->peer, bc->do_hello));
-      GNUNET_free (bc);
-      return;
-    }
+    bc->cont (bc->cont_cls, setup_new_neighbour (&bc->peer, bc->do_hello));
+    GNUNET_free (bc);
+    return;
+  }
   if (bl->bc == NULL)
-    {
-      bl->bc = bc;
-      bc->th = GNUNET_SERVER_notify_transmit_ready (bl->client,
-                                                    sizeof (struct BlacklistMessage),
-                                                    GNUNET_TIME_UNIT_FOREVER_REL,
-                                                    &transmit_blacklist_message,
-                                                    bc);
-    }
+  {
+    bl->bc = bc;
+    bc->th = GNUNET_SERVER_notify_transmit_ready (bl->client,
+                                                  sizeof (struct
+                                                          BlacklistMessage),
+                                                  GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  &transmit_blacklist_message,
+                                                  bc);
+  }
 }
 
 
@@ -3509,33 +3425,31 @@ do_blacklist_check (void *cls,
  */
 static void
 setup_peer_check_blacklist (const struct GNUNET_PeerIdentity *peer,
-                            int do_hello,
-                            SetupContinuation cont,
-                            void *cont_cls)
+                            int do_hello,
+                            SetupContinuation cont, void *cont_cls)
 {
   struct NeighbourMapEntry *n;
   struct BlacklistCheck *bc;
 
-  n = find_neighbour(peer);
+  n = find_neighbour (peer);
   if (n != NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 
-                 "Neighbour record exists for peer `%s'\n", 
-                 GNUNET_i2s(peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Neighbour record exists for peer `%s'\n", GNUNET_i2s (peer));
 #endif
-      if (cont != NULL)
-        cont (cont_cls, n);
-      return;
-    }
+    if (cont != NULL)
+      cont (cont_cls, n);
+    return;
+  }
   if (bl_head == NULL)
-    {
-      if (cont != NULL)
-        cont (cont_cls, setup_new_neighbour (peer, do_hello));
-      else
-        setup_new_neighbour(peer, do_hello);
-      return;
-    }
+  {
+    if (cont != NULL)
+      cont (cont_cls, setup_new_neighbour (peer, do_hello));
+    else
+      setup_new_neighbour (peer, do_hello);
+    return;
+  }
   bc = GNUNET_malloc (sizeof (struct BlacklistCheck));
   GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
   bc->peer = *peer;
@@ -3543,8 +3457,7 @@ setup_peer_check_blacklist (const struct GNUNET_PeerIdentity *peer,
   bc->cont = cont;
   bc->cont_cls = cont_cls;
   bc->bl_pos = bl_head;
-  bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                       bc);
+  bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
 }
 
 
@@ -3556,24 +3469,22 @@ setup_peer_check_blacklist (const struct GNUNET_PeerIdentity *peer,
  * @param n NULL if we need to disconnect
  */
 static void
-confirm_or_drop_neighbour (void *cls,
-                           struct NeighbourMapEntry *n)
+confirm_or_drop_neighbour (void *cls, struct NeighbourMapEntry *n)
 {
-  struct NeighbourMapEntry * orig = cls;
+  struct NeighbourMapEntry *orig = cls;
 
   if (n == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&orig->id),
-              "confirm_or_drop_neighboUr");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting peer `%4s', %s\n", GNUNET_i2s (&orig->id),
+                "confirm_or_drop_neighboUr");
 #endif
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# disconnects due to blacklist"),
-                                1,
-                                GNUNET_NO);
-      disconnect_neighbour (orig, GNUNET_NO);
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# disconnects due to blacklist"),
+                              1, GNUNET_NO);
+    disconnect_neighbour (orig, GNUNET_NO);
+  }
 }
 
 
@@ -3586,15 +3497,13 @@ struct TestConnectionContext
 
 
 static int
-test_connection_ok (void *cls,
-                    const GNUNET_HashCode *key,
-                    void *value)
+test_connection_ok (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct TestConnectionContext *tcc = cls;
   struct NeighbourMapEntry *n = value;
   struct BlacklistCheck *bc;
 
-  
+
   bc = GNUNET_malloc (sizeof (struct BlacklistCheck));
   GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
   bc->peer = n->id;
@@ -3603,13 +3512,12 @@ test_connection_ok (void *cls,
   bc->cont_cls = n;
   bc->bl_pos = tcc->bl;
   if (GNUNET_YES == tcc->first)
-    { 
-      /* all would wait for the same client, no need to
-         create more than just the first task right now */
-      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                           bc);
-      tcc->first = GNUNET_NO;
-    }
+  {
+    /* all would wait for the same client, no need to
+     * create more than just the first task right now */
+    bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+    tcc->first = GNUNET_NO;
+  }
   return GNUNET_OK;
 }
 
@@ -3623,23 +3531,23 @@ test_connection_ok (void *cls,
  */
 static void
 handle_blacklist_init (void *cls,
-                       struct GNUNET_SERVER_Client *client,
-                       const struct GNUNET_MessageHeader *message)
+                       struct GNUNET_SERVER_Client *client,
+                       const struct GNUNET_MessageHeader *message)
 {
   struct Blacklisters *bl;
   struct TestConnectionContext tcc;
 
   bl = bl_head;
   while (bl != NULL)
+  {
+    if (bl->client == client)
     {
-      if (bl->client == client)
-        {
-          GNUNET_break (0);
-          GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-          return;
-        }
-      bl = bl->next;
+      GNUNET_break (0);
+      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+      return;
     }
+    bl = bl->next;
+  }
   bl = GNUNET_malloc (sizeof (struct Blacklisters));
   bl->client = client;
   GNUNET_SERVER_client_keep (client);
@@ -3647,9 +3555,7 @@ handle_blacklist_init (void *cls,
   /* confirm that all existing connections are OK! */
   tcc.bl = bl;
   tcc.first = GNUNET_YES;
-  GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &test_connection_ok,
-                                         &tcc);
+  GNUNET_CONTAINER_multihashmap_iterate (neighbours, &test_connection_ok, &tcc);
 }
 
 
@@ -3662,59 +3568,55 @@ handle_blacklist_init (void *cls,
  */
 static void
 handle_blacklist_reply (void *cls,
-                        struct GNUNET_SERVER_Client *client,
-                        const struct GNUNET_MessageHeader *message)
+                        struct GNUNET_SERVER_Client *client,
+                        const struct GNUNET_MessageHeader *message)
 {
-  const struct BlacklistMessage *msg = (const struct BlacklistMessage*) message;
+  const struct BlacklistMessage *msg =
+      (const struct BlacklistMessage *) message;
   struct Blacklisters *bl;
   struct BlacklistCheck *bc;
 
   bl = bl_head;
-  while ( (bl != NULL) &&
-          (bl->client != client) )
+  while ((bl != NULL) && (bl->client != client))
     bl = bl->next;
   if (bl == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Blacklist client disconnected\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Blacklist client disconnected\n");
 #endif
-      /* FIXME: other error handling here!? */
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+    /* FIXME: other error handling here!? */
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   bc = bl->bc;
   bl->bc = NULL;
   if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Blacklist check failed, peer not allowed\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Blacklist check failed, peer not allowed\n");
 #endif
-      bc->cont (bc->cont_cls, NULL);
-      GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
-      GNUNET_free (bc);
-    }
+    bc->cont (bc->cont_cls, NULL);
+    GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
+    GNUNET_free (bc);
+  }
   else
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Blacklist check succeeded, continuing with checks\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Blacklist check succeeded, continuing with checks\n");
 #endif
-      bc->bl_pos = bc->bl_pos->next;
-      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                           bc);
-    }
+    bc->bl_pos = bc->bl_pos->next;
+    bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+  }
   /* check if any other bc's are waiting for this blacklister */
   bc = bc_head;
   while (bc != NULL)
-    {
-      if ( (bc->bl_pos == bl) &&
-           (GNUNET_SCHEDULER_NO_TASK == bc->task) )
-        bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                             bc);
-      bc = bc->next;
-    }
+  {
+    if ((bc->bl_pos == bl) && (GNUNET_SCHEDULER_NO_TASK == bc->task))
+      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+    bc = bc->next;
+  }
 }
 
 
@@ -3725,8 +3627,7 @@ handle_blacklist_reply (void *cls,
  * @param tc task context
  */
 static void
-send_periodic_ping (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+send_periodic_ping (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ForeignAddressList *peer_address = cls;
   struct TransportPlugin *tp;
@@ -3734,23 +3635,23 @@ send_periodic_ping (void *cls,
   struct NeighbourMapEntry *neighbour;
   struct TransportPingMessage ping;
   struct CheckAddressExistsClosure caec;
-  char * message_buf;
+  char *message_buf;
   uint16_t hello_size;
   size_t slen;
   size_t tsize;
 
   peer_address->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
   GNUNET_assert (peer_address != NULL);
   tp = peer_address->ready_list->plugin;
   neighbour = peer_address->ready_list->neighbour;
   if (GNUNET_YES != neighbour->public_key_valid)
-    {
-      /* no public key yet, try again later */
-      schedule_next_ping (peer_address);
-      return;
-    }
+  {
+    /* no public key yet, try again later */
+    schedule_next_ping (peer_address);
+    return;
+  }
   caec.addr = peer_address->addr;
   caec.addrlen = peer_address->addrlen;
   caec.tname = tp->short_name;
@@ -3758,43 +3659,40 @@ send_periodic_ping (void *cls,
   caec.exists = GNUNET_NO;
 
   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
-                                         &check_address_exists,
-                                         &caec);
+                                         &check_address_exists, &caec);
   if (caec.exists == GNUNET_YES)
-    {
-      /* During validation attempts we will likely trigger the other
-         peer trying to validate our address which in turn will cause
-         it to send us its HELLO, so we expect to hit this case rather
-         frequently.  Only print something if we are very verbose. */
+  {
+    /* During validation attempts we will likely trigger the other
+     * peer trying to validate our address which in turn will cause
+     * it to send us its HELLO, so we expect to hit this case rather
+     * frequently.  Only print something if we are very verbose. */
 #if DEBUG_TRANSPORT > 1
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Some validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
-                  (peer_address->addr != NULL)
-                  ? a2s (tp->short_name,
-                         peer_address->addr,
-                         peer_address->addrlen)
-                  : "<inbound>",
-                  tp->short_name,
-                  GNUNET_i2s (&neighbour->id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Some validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
+                (peer_address->addr != NULL)
+                ? a2s (tp->short_name,
+                       peer_address->addr,
+                       peer_address->addrlen)
+                : "<inbound>", tp->short_name, GNUNET_i2s (&neighbour->id));
 #endif
-      schedule_next_ping (peer_address);
-      return;
-    }
+    schedule_next_ping (peer_address);
+    return;
+  }
   va = GNUNET_malloc (sizeof (struct ValidationEntry) + peer_address->addrlen);
   va->transport_name = GNUNET_strdup (tp->short_name);
   va->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                             UINT_MAX);
-  va->send_time = GNUNET_TIME_absolute_get();
+  va->send_time = GNUNET_TIME_absolute_get ();
   va->session = peer_address->session;
   if (peer_address->addr != NULL)
-    {
-      va->addr = (const void*) &va[1];
-      memcpy (&va[1], peer_address->addr, peer_address->addrlen);
-      va->addrlen = peer_address->addrlen;
-    }
-  memcpy(&va->publicKey,
-         &neighbour->publicKey,
-         sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+  {
+    va->addr = (const void *) &va[1];
+    memcpy (&va[1], peer_address->addr, peer_address->addrlen);
+    va->addrlen = peer_address->addrlen;
+  }
+  memcpy (&va->publicKey,
+          &neighbour->publicKey,
+          sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
 
   va->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
                                                    &timeout_hello_validation,
@@ -3805,83 +3703,75 @@ send_periodic_ping (void *cls,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 
   if (peer_address->validated != GNUNET_YES)
-    hello_size = GNUNET_HELLO_size(our_hello);
+    hello_size = GNUNET_HELLO_size (our_hello);
   else
     hello_size = 0;
 
-  tsize = sizeof(struct TransportPingMessage) + hello_size;
+  tsize = sizeof (struct TransportPingMessage) + hello_size;
 
   if (peer_address->addr != NULL)
-    {
-      slen = strlen (tp->short_name) + 1;
-      tsize += slen + peer_address->addrlen;
-    }
+  {
+    slen = strlen (tp->short_name) + 1;
+    tsize += slen + peer_address->addrlen;
+  }
   else
-    {
-      slen = 0; /* make gcc happy */
-    }
-  message_buf = GNUNET_malloc(tsize);
-  ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
-  ping.challenge = htonl(va->challenge);
-  memcpy(&ping.target, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
+  {
+    slen = 0;                   /* make gcc happy */
+  }
+  message_buf = GNUNET_malloc (tsize);
+  ping.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
+  ping.challenge = htonl (va->challenge);
+  memcpy (&ping.target, &neighbour->id, sizeof (struct GNUNET_PeerIdentity));
   if (peer_address->validated != GNUNET_YES)
-    {
-      memcpy(message_buf, our_hello, hello_size);
-    }
+  {
+    memcpy (message_buf, our_hello, hello_size);
+  }
 
   if (peer_address->addr != NULL)
-    {
-      ping.header.size = htons(sizeof(struct TransportPingMessage) +
-                               peer_address->addrlen +
-                               slen);
-      memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage)],
-             tp->short_name,
-             slen);
-      memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage) + slen],
-             peer_address->addr,
-             peer_address->addrlen);
-    }
+  {
+    ping.header.size = htons (sizeof (struct TransportPingMessage) +
+                              peer_address->addrlen + slen);
+    memcpy (&message_buf[hello_size + sizeof (struct TransportPingMessage)],
+            tp->short_name, slen);
+    memcpy (&message_buf
+            [hello_size + sizeof (struct TransportPingMessage) + slen],
+            peer_address->addr, peer_address->addrlen);
+  }
   else
-    {
-      ping.header.size = htons(sizeof(struct TransportPingMessage));
-    }
+  {
+    ping.header.size = htons (sizeof (struct TransportPingMessage));
+  }
 
-  memcpy(&message_buf[hello_size],
-         &ping,
-         sizeof(struct TransportPingMessage));
+  memcpy (&message_buf[hello_size],
+          &ping, sizeof (struct TransportPingMessage));
 
 #if DEBUG_TRANSPORT_REVALIDATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Performing re-validation of address `%s' via `%s' for peer `%4s' sending `%s' (%u bytes) and `%s'\n",
               (peer_address->addr != NULL)
-              ? a2s (peer_address->plugin->short_name,
-                     peer_address->addr,
-                     peer_address->addrlen)
-              : "<inbound>",
+              ? a2s (peer_address->plugin->short_name,
+                     peer_address->addr,
+                     peer_address->addrlen)
+              : "<inbound>",
               tp->short_name,
-              GNUNET_i2s (&neighbour->id),
-              "HELLO", hello_size,
-              "PING");
+              GNUNET_i2s (&neighbour->id), "HELLO", hello_size, "PING");
 #endif
   if (peer_address->validated != GNUNET_YES)
     GNUNET_STATISTICS_update (stats,
                               gettext_noop ("# PING with HELLO messages sent"),
-                              1,
-                              GNUNET_NO);
+                              1, GNUNET_NO);
   else
     GNUNET_STATISTICS_update (stats,
-                              gettext_noop ("# PING without HELLO messages sent"),
-                              1,
+                              gettext_noop
+                              ("# PING without HELLO messages sent"), 1,
                               GNUNET_NO);
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# PING messages sent for re-validation"),
-                            1,
-                            GNUNET_NO);
-  transmit_to_peer (NULL, peer_address,
-                    GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                    HELLO_VERIFICATION_TIMEOUT,
-                    message_buf, tsize,
-                    GNUNET_YES, neighbour);
+                            gettext_noop
+                            ("# PING messages sent for re-validation"), 1,
+                            GNUNET_NO);
+  transmit_to_peer (NULL, peer_address, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                    HELLO_VERIFICATION_TIMEOUT, message_buf, tsize, GNUNET_YES,
+                    neighbour);
   GNUNET_free (message_buf);
   schedule_next_ping (peer_address);
 }
@@ -3899,37 +3789,36 @@ schedule_next_ping (struct ForeignAddressList *fal)
   struct GNUNET_TIME_Relative delay;
 
   if (fal->revalidate_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(fal->revalidate_task);
-      fal->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (fal->revalidate_task);
+    fal->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   delay = GNUNET_TIME_absolute_get_remaining (fal->expires);
-  delay.rel_value /= 2; /* do before expiration */
-  delay = GNUNET_TIME_relative_min (delay,
-                                    LATENCY_EVALUATION_MAX_DELAY);
+  delay.rel_value /= 2;         /* do before expiration */
+  delay = GNUNET_TIME_relative_min (delay, LATENCY_EVALUATION_MAX_DELAY);
   if (GNUNET_YES != fal->estimated)
-    {
-      delay = GNUNET_TIME_UNIT_ZERO;
-      fal->estimated = GNUNET_YES;
-    }
+  {
+    delay = GNUNET_TIME_UNIT_ZERO;
+    fal->estimated = GNUNET_YES;
+  }
 
   if (GNUNET_YES == fal->connected)
-    {
-      delay = GNUNET_TIME_relative_min (delay,
-                                        CONNECTED_LATENCY_EVALUATION_MAX_DELAY);
-    }
+  {
+    delay = GNUNET_TIME_relative_min (delay,
+                                      CONNECTED_LATENCY_EVALUATION_MAX_DELAY);
+  }
   /* FIXME: also adjust delay based on how close the last
-     observed latency is to the latency of the best alternative */
+   * observed latency is to the latency of the best alternative */
   /* bound how fast we can go */
-  delay = GNUNET_TIME_relative_max (delay,
-                                    GNUNET_TIME_UNIT_SECONDS);
+  delay = GNUNET_TIME_relative_max (delay, GNUNET_TIME_UNIT_SECONDS);
   /* randomize a bit (to avoid doing all at the same time) */
-  delay.rel_value += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000);
+  delay.rel_value +=
+      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000);
 
   GNUNET_assert (fal->revalidate_task == GNUNET_SCHEDULER_NO_TASK);
-  fal->revalidate_task = GNUNET_SCHEDULER_add_delayed(delay,
-                                                      &send_periodic_ping,
-                                                      fal);
+  fal->revalidate_task = GNUNET_SCHEDULER_add_delayed (delay,
+                                                       &send_periodic_ping,
+                                                       fal);
 }
 
 
@@ -3944,7 +3833,7 @@ schedule_next_ping (struct ForeignAddressList *fal)
  */
 static void
 handle_payload_message (const struct GNUNET_MessageHeader *message,
-                        struct NeighbourMapEntry *n)
+                        struct NeighbourMapEntry *n)
 {
   struct InboundMessage *im;
   struct TransportClient *cpos;
@@ -3952,66 +3841,64 @@ handle_payload_message (const struct GNUNET_MessageHeader *message,
 
   msize = ntohs (message->size);
   if (n->received_pong == GNUNET_NO)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received message of type %u and size %u from `%4s', but no pong yet!\n",
-                  ntohs (message->type),
-                  ntohs (message->size),
-                  GNUNET_i2s (&n->id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received message of type %u and size %u from `%4s', but no pong yet!\n",
+                ntohs (message->type),
+                ntohs (message->size), GNUNET_i2s (&n->id));
 #endif
-      GNUNET_free_non_null (n->pre_connect_message_buffer);
-      n->pre_connect_message_buffer = GNUNET_malloc (msize);
-      memcpy (n->pre_connect_message_buffer, message, msize);
-      return;
-    }
+    GNUNET_free_non_null (n->pre_connect_message_buffer);
+    n->pre_connect_message_buffer = GNUNET_malloc (msize);
+    memcpy (n->pre_connect_message_buffer, message, msize);
+    return;
+  }
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received message of type %u and size %u from `%4s', sending to all clients.\n",
-              ntohs (message->type),
-              ntohs (message->size),
-              GNUNET_i2s (&n->id));
+              "Received message of type %u and size %u from `%4s', sending to all clients.\n",
+              ntohs (message->type),
+              ntohs (message->size), GNUNET_i2s (&n->id));
 #endif
   if (GNUNET_YES == GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
-                                                      (ssize_t) msize))
-    {
-      n->quota_violation_count++;
+                                                      (ssize_t) msize))
+  {
+    n->quota_violation_count++;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
-                  n->in_tracker.available_bytes_per_s__,
-                  n->quota_violation_count);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
+                n->in_tracker.available_bytes_per_s__,
+                n->quota_violation_count);
 #endif
-      /* Discount 32k per violation */
-      GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
-                                        - 32 * 1024);
-    }
+    /* Discount 32k per violation */
+    GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, -32 * 1024);
+  }
   else
+  {
+    if (n->quota_violation_count > 0)
     {
-      if (n->quota_violation_count > 0)
-        {
-          /* try to add 32k back */
-          GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
-                                            32 * 1024);
-          n->quota_violation_count--;
-        }
+      /* try to add 32k back */
+      GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, 32 * 1024);
+      n->quota_violation_count--;
     }
+  }
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# payload received from other peers"),
-                            msize,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# payload received from other peers"), msize,
+                            GNUNET_NO);
   /* transmit message to all clients */
   uint32_t ats_count = 2;
-  size_t size = sizeof (struct InboundMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) + msize;
+  size_t size =
+      sizeof (struct InboundMessage) +
+      ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) + msize;
   if (size > GNUNET_SERVER_MAX_MESSAGE_SIZE)
-          GNUNET_break(0);
+    GNUNET_break (0);
 
   im = GNUNET_malloc (size);
   im->header.size = htons (size);
   im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
   im->peer = n->id;
-  im->ats_count = htonl(ats_count);
+  im->ats_count = htonl (ats_count);
   /* Setting ATS data */
   (&(im->ats))[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
   (&(im->ats))[0].value = htonl (n->distance);
@@ -4020,13 +3907,13 @@ handle_payload_message (const struct GNUNET_MessageHeader *message,
   (&(im->ats))[ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   (&(im->ats))[ats_count].value = htonl (0);
 
-  memcpy (&((&(im->ats))[ats_count+1]), message, msize);
+  memcpy (&((&(im->ats))[ats_count + 1]), message, msize);
   cpos = clients;
   while (cpos != NULL)
-    {
-      transmit_to_client (cpos, &im->header, GNUNET_YES);
-      cpos = cpos->next;
-    }
+  {
+    transmit_to_client (cpos, &im->header, GNUNET_YES);
+    cpos = cpos->next;
+  }
   GNUNET_free (im);
 }
 
@@ -4042,14 +3929,12 @@ handle_payload_message (const struct GNUNET_MessageHeader *message,
  *         iterate (mismatch), GNUNET_NO if not (entry matched)
  */
 static int
-check_pending_validation (void *cls,
-                          const GNUNET_HashCode * key,
-                          void *value)
+check_pending_validation (void *cls, const GNUNET_HashCode * key, void *value)
 {
   const struct TransportPongMessage *pong = cls;
   struct ValidationEntry *ve = value;
   struct AddValidatedAddressContext avac;
-  unsigned int challenge = ntohl(pong->challenge);
+  unsigned int challenge = ntohl (pong->challenge);
   struct GNUNET_HELLO_Message *hello;
   struct GNUNET_PeerIdentity target;
   struct NeighbourMapEntry *n;
@@ -4064,217 +3949,201 @@ check_pending_validation (void *cls,
 
   ps = ntohs (pong->header.size);
   if (ps < sizeof (struct TransportPongMessage))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
+  addr = (const char *) &pong[1];
+  slen = strlen (ve->transport_name) + 1;
+  if ((ps - sizeof (struct TransportPongMessage) < slen) ||
+      (ve->challenge != challenge) ||
+      (addr[slen - 1] != '\0') ||
+      (0 != strcmp (addr, ve->transport_name)) ||
+      (ntohl (pong->purpose.size)
+       != sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
+       sizeof (uint32_t) +
+       sizeof (struct GNUNET_TIME_AbsoluteNBO) +
+       sizeof (struct GNUNET_PeerIdentity) + ps -
+       sizeof (struct TransportPongMessage)))
+  {
+    return GNUNET_YES;
+  }
+
+  alen = ps - sizeof (struct TransportPongMessage) - slen;
+  switch (ntohl (pong->purpose.purpose))
+  {
+  case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN:
+    if ((ve->addrlen + slen != ntohl (pong->addrlen)) ||
+        (0 != memcmp (&addr[slen], ve->addr, ve->addrlen)))
+    {
+      return GNUNET_YES;        /* different entry, keep trying! */
+    }
+    if (0 != memcmp (&pong->pid, key, sizeof (struct GNUNET_PeerIdentity)))
     {
       GNUNET_break_op (0);
       return GNUNET_NO;
     }
-  addr = (const char*) &pong[1];
-  slen = strlen (ve->transport_name) + 1;
-  if ( (ps - sizeof (struct TransportPongMessage) < slen) ||
-       (ve->challenge != challenge) ||
-       (addr[slen-1] != '\0') ||
-       (0 != strcmp (addr, ve->transport_name)) ||
-       (ntohl (pong->purpose.size)
-        != sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
-        sizeof (uint32_t) +
-        sizeof (struct GNUNET_TIME_AbsoluteNBO) +
-        sizeof (struct GNUNET_PeerIdentity) + ps - sizeof (struct TransportPongMessage)) )
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
+                                  &pong->purpose,
+                                  &pong->signature, &ve->publicKey))
     {
-      return GNUNET_YES;
+      GNUNET_break_op (0);
+      return GNUNET_NO;
     }
 
-  alen = ps - sizeof (struct TransportPongMessage) - slen;
-  switch (ntohl (pong->purpose.purpose))
-    {
-    case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN:
-      if ( (ve->addrlen + slen != ntohl (pong->addrlen)) ||
-           (0 != memcmp (&addr[slen],
-                         ve->addr,
-                         ve->addrlen)) )
-        {
-          return GNUNET_YES; /* different entry, keep trying! */
-        }
-      if (0 != memcmp (&pong->pid,
-                       key,
-                       sizeof (struct GNUNET_PeerIdentity)))
-        {
-          GNUNET_break_op (0);
-          return GNUNET_NO;
-        }
-      if (GNUNET_OK !=
-          GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
-                                    &pong->purpose,
-                                    &pong->signature,
-                                    &ve->publicKey))
-        {
-          GNUNET_break_op (0);
-          return GNUNET_NO;
-        }
-
-#if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Confirmed validity of address, peer `%4s' has address `%s' (%s).\n",
-                  GNUNET_h2s (key),
-                  a2s (ve->transport_name,
-                       (const struct sockaddr *) ve->addr,
-                       ve->addrlen),
-                  ve->transport_name);
-#endif
-      break;
-    case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING:
-      if (0 != memcmp (&pong->pid,
-                         &my_identity,
-                         sizeof (struct GNUNET_PeerIdentity)))
-        {
-          char * peer;
-
-          GNUNET_asprintf(&peer, "%s",GNUNET_i2s (&pong->pid));
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Received PONG for different identity: I am `%s', PONG identity: `%s'\n",
-                      GNUNET_i2s (&my_identity), 
-                      peer );
-#endif
-          GNUNET_free (peer);
-          return GNUNET_NO;
-        }
-      if (ve->addrlen != 0)
-        {
-          /* must have been for a different validation entry */
-          return GNUNET_YES;
-        }
-      tp = find_transport (ve->transport_name);
-      if (tp == NULL)
-        {
-          GNUNET_break (0);
-          return GNUNET_YES;
-        }
-      oal = tp->addresses;
-      while (NULL != oal)
-        {
-          if ( (oal->addrlen == alen) &&
-               (0 == memcmp (&oal[1],
-                             &addr[slen],
-                             alen)) )
-            break;
-          oal = oal->next;
-        }
-      if (oal == NULL)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Not accepting PONG from `%s' with address `%s' since I cannot confirm using this address.\n"),
-                      GNUNET_i2s (&pong->pid),
-                      a2s (ve->transport_name,
-                           &addr[slen],
-                           alen));
-          /* FIXME: since the sender of the PONG currently uses the
-             wrong address (see FIMXE there!), we cannot run a 
-             proper check here... */
-#if FIXME_URGENT
-          return GNUNET_NO;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Confirmed validity of address, peer `%4s' has address `%s' (%s).\n",
+                GNUNET_h2s (key),
+                a2s (ve->transport_name,
+                     (const struct sockaddr *) ve->addr,
+                     ve->addrlen), ve->transport_name);
 #endif
-        }
-      if (GNUNET_OK !=
-          GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING,
-                                    &pong->purpose,
-                                    &pong->signature,
-                                    &ve->publicKey))
-        {
-          GNUNET_break_op (0);
-          return GNUNET_NO;
-        }
+    break;
+  case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING:
+    if (0 != memcmp (&pong->pid,
+                     &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+    {
+      char *peer;
 
+      GNUNET_asprintf (&peer, "%s", GNUNET_i2s (&pong->pid));
 #if DEBUG_TRANSPORT
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Confirmed that peer `%4s' is talking to us using address `%s' (%s) for us.\n",
-                  GNUNET_h2s (key),
-                  a2s (ve->transport_name,
-                       &addr[slen],
-                       alen),
-                  ve->transport_name);
+                  "Received PONG for different identity: I am `%s', PONG identity: `%s'\n",
+                  GNUNET_i2s (&my_identity), peer);
 #endif
-      break;
-    default:
-      GNUNET_break_op (0);
+      GNUNET_free (peer);
       return GNUNET_NO;
     }
-  if (GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (pong->expiration)).rel_value == 0)
+    if (ve->addrlen != 0)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Received expired signature.  Check system time.\n"));
+      /* must have been for a different validation entry */
+      return GNUNET_YES;
+    }
+    tp = find_transport (ve->transport_name);
+    if (tp == NULL)
+    {
+      GNUNET_break (0);
+      return GNUNET_YES;
+    }
+    oal = tp->addresses;
+    while (NULL != oal)
+    {
+      if ((oal->addrlen == alen) && (0 == memcmp (&oal[1], &addr[slen], alen)))
+        break;
+      oal = oal->next;
+    }
+    if (oal == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Not accepting PONG from `%s' with address `%s' since I cannot confirm using this address.\n"),
+                  GNUNET_i2s (&pong->pid), a2s (ve->transport_name, &addr[slen],
+                                                alen));
+      /* FIXME: since the sender of the PONG currently uses the
+       * wrong address (see FIMXE there!), we cannot run a 
+       * proper check here... */
+#if FIXME_URGENT
       return GNUNET_NO;
+#endif
     }
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING,
+                                  &pong->purpose,
+                                  &pong->signature, &ve->publicKey))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+
+#if DEBUG_TRANSPORT
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Confirmed that peer `%4s' is talking to us using address `%s' (%s) for us.\n",
+                GNUNET_h2s (key),
+                a2s (ve->transport_name,
+                     &addr[slen], alen), ve->transport_name);
+#endif
+    break;
+  default:
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
+  if (GNUNET_TIME_absolute_get_remaining
+      (GNUNET_TIME_absolute_ntoh (pong->expiration)).rel_value == 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("Received expired signature.  Check system time.\n"));
+    return GNUNET_NO;
+  }
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# address validation successes"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# address validation successes"),
+                            1, GNUNET_NO);
   /* create the updated HELLO */
   GNUNET_CRYPTO_hash (&ve->publicKey,
                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
                       &target.hashPubKey);
   if (ve->addr != NULL)
-    {
-      avac.done = GNUNET_NO;
-      avac.ve = ve;
-      hello = GNUNET_HELLO_create (&ve->publicKey,
-                                   &add_validated_address,
-                                   &avac);
-      GNUNET_PEERINFO_add_peer (peerinfo,
-                                hello);
-      GNUNET_free (hello);
-    }
+  {
+    avac.done = GNUNET_NO;
+    avac.ve = ve;
+    hello = GNUNET_HELLO_create (&ve->publicKey, &add_validated_address, &avac);
+    GNUNET_PEERINFO_add_peer (peerinfo, hello);
+    GNUNET_free (hello);
+  }
   n = find_neighbour (&target);
   if (n != NULL)
+  {
+    n->publicKey = ve->publicKey;
+    n->public_key_valid = GNUNET_YES;
+    fal = add_peer_address (n,
+                            ve->transport_name,
+                            ve->session, ve->addr, ve->addrlen);
+    GNUNET_assert (fal != NULL);
+    fal->expires = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
+    fal->validated = GNUNET_YES;
+    mark_address_connected (fal);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# peer addresses considered valid"), 1,
+                              GNUNET_NO);
+    fal->latency = GNUNET_TIME_absolute_get_duration (ve->send_time);
+    update_addr_value (fal,
+                       GNUNET_TIME_absolute_get_duration (ve->
+                                                          send_time).rel_value,
+                       GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
+
+    schedule_next_ping (fal);
+    if (n->latency.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+      n->latency = fal->latency;
+    else
+      n->latency.rel_value =
+          (fal->latency.rel_value + n->latency.rel_value) / 2;
+
+    n->distance = fal->distance;
+    if (GNUNET_NO == n->received_pong)
+    {
+      n->received_pong = GNUNET_YES;
+      notify_clients_connect (&target, n->latency, n->distance);
+      if (NULL != (prem = n->pre_connect_message_buffer))
+      {
+        n->pre_connect_message_buffer = NULL;
+        handle_payload_message (prem, n);
+        GNUNET_free (prem);
+      }
+    }
+    if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      n->publicKey = ve->publicKey;
-      n->public_key_valid = GNUNET_YES;
-      fal = add_peer_address (n,
-                              ve->transport_name,
-                              ve->session,
-                              ve->addr,
-                              ve->addrlen);
-      GNUNET_assert (fal != NULL);
-      fal->expires = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
-      fal->validated = GNUNET_YES;
-      mark_address_connected (fal);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# peer addresses considered valid"),
-                                1,
-                                GNUNET_NO);
-      fal->latency = GNUNET_TIME_absolute_get_duration (ve->send_time);
-      update_addr_value (fal, GNUNET_TIME_absolute_get_duration (ve->send_time).rel_value, GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
-
-      schedule_next_ping (fal);
-      if (n->latency.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
-        n->latency = fal->latency;
-      else
-        n->latency.rel_value = (fal->latency.rel_value + n->latency.rel_value) / 2;
-
-      n->distance = fal->distance;
-      if (GNUNET_NO == n->received_pong)
-        {
-          n->received_pong = GNUNET_YES;
-          notify_clients_connect (&target, n->latency, n->distance);
-          if (NULL != (prem = n->pre_connect_message_buffer))
-            {
-              n->pre_connect_message_buffer = NULL;
-              handle_payload_message (prem, n);
-              GNUNET_free (prem);
-            }
-        }
-      if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (n->retry_task);
-          n->retry_task = GNUNET_SCHEDULER_NO_TASK;
-          try_transmission_to_peer (n);
-        }
+      GNUNET_SCHEDULER_cancel (n->retry_task);
+      n->retry_task = GNUNET_SCHEDULER_NO_TASK;
+      try_transmission_to_peer (n);
     }
+  }
 
   /* clean up validation entry */
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (validation_map,
-                                                       key,
-                                                       ve));
+                 GNUNET_CONTAINER_multihashmap_remove (validation_map,
+                                                       key, ve));
   abort_validation (NULL, NULL, ve);
   return GNUNET_NO;
 }
@@ -4298,51 +4167,44 @@ check_pending_validation (void *cls,
 static void
 handle_pong (void *cls, const struct GNUNET_MessageHeader *message,
              const struct GNUNET_PeerIdentity *peer,
-             const char *sender_address,
-             size_t sender_address_len)
+             const char *sender_address, size_t sender_address_len)
 {
-  if (0 == memcmp (peer,
-                   &my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      /* PONG send to self, ignore */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receiving `%s' message from myself\n", 
-                  "PONG");
-      return;
-    }
+  if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    /* PONG send to self, ignore */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receiving `%s' message from myself\n", "PONG");
+    return;
+  }
 #if DEBUG_TRANSPORT > 1
   /* we get tons of these that just get discarded, only log
-     if we are quite verbose */
+   * if we are quite verbose */
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving `%s' message from `%4s'.\n", "PONG",
-              GNUNET_i2s (peer));
+              "Receiving `%s' message from `%4s'.\n", "PONG",
+              GNUNET_i2s (peer));
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# PONG messages received"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# PONG messages received"),
+                            1, GNUNET_NO);
   if (GNUNET_SYSERR !=
       GNUNET_CONTAINER_multihashmap_get_multiple (validation_map,
-                                                  &peer->hashPubKey,
-                                                  &check_pending_validation,
-                                                  (void*) message))
-    {
-      /* This is *expected* to happen a lot since we send
-         PONGs to *all* known addresses of the sender of
-         the PING, so most likely we get multiple PONGs
-         per PING, and all but the first PONG will end up
-         here. So really we should not print anything here
-         unless we want to be very, very verbose... */
+                                                  &peer->hashPubKey,
+                                                  &check_pending_validation,
+                                                  (void *) message))
+  {
+    /* This is *expected* to happen a lot since we send
+     * PONGs to *all* known addresses of the sender of
+     * the PING, so most likely we get multiple PONGs
+     * per PING, and all but the first PONG will end up
+     * here. So really we should not print anything here
+     * unless we want to be very, very verbose... */
 #if DEBUG_TRANSPORT > 2
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received `%s' message from `%4s' but have no record of a matching `%s' message. Ignoring.\n",
-                  "PONG",
-                  GNUNET_i2s (peer),
-                  "PING");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received `%s' message from `%4s' but have no record of a matching `%s' message. Ignoring.\n",
+                "PONG", GNUNET_i2s (peer), "PING");
 #endif
-      return;
-    }
+    return;
+  }
 
 }
 
@@ -4354,92 +4216,86 @@ handle_pong (void *cls, const struct GNUNET_MessageHeader *message,
  * @param neighbour neighbour to validate, NULL if validation failed
  */
 static void
-transmit_hello_and_ping (void *cls,
-                         struct NeighbourMapEntry *neighbour)
+transmit_hello_and_ping (void *cls, struct NeighbourMapEntry *neighbour)
 {
   struct ValidationEntry *va = cls;
   struct ForeignAddressList *peer_address;
   struct TransportPingMessage ping;
   uint16_t hello_size;
   size_t tsize;
-  char * message_buf;
+  char *message_buf;
   struct GNUNET_PeerIdentity id;
   size_t slen;
 
   GNUNET_CRYPTO_hash (&va->publicKey,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &id.hashPubKey);
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &id.hashPubKey);
   if (neighbour == NULL)
-    {
-      /* FIXME: stats... */
-      GNUNET_break (GNUNET_OK ==
-                    GNUNET_CONTAINER_multihashmap_remove (validation_map,
-                                                          &id.hashPubKey,
-                                                          va));
-      abort_validation (NULL, NULL, va);
-      return;
-    }
+  {
+    /* FIXME: stats... */
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_remove (validation_map,
+                                                        &id.hashPubKey, va));
+    abort_validation (NULL, NULL, va);
+    return;
+  }
   neighbour->publicKey = va->publicKey;
   neighbour->public_key_valid = GNUNET_YES;
   peer_address = add_peer_address (neighbour,
-                                   va->transport_name, NULL,
-                                   (const void*) &va[1],
-                                   va->addrlen);
+                                   va->transport_name, NULL,
+                                   (const void *) &va[1], va->addrlen);
   if (peer_address == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Failed to add peer `%4s' for plugin `%s'\n",
-                  GNUNET_i2s (&neighbour->id),
-                  va->transport_name);
-      GNUNET_break (GNUNET_OK ==
-                    GNUNET_CONTAINER_multihashmap_remove (validation_map,
-                                                          &id.hashPubKey,
-                                                          va));
-      abort_validation (NULL, NULL, va);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to add peer `%4s' for plugin `%s'\n",
+                GNUNET_i2s (&neighbour->id), va->transport_name);
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_remove (validation_map,
+                                                        &id.hashPubKey, va));
+    abort_validation (NULL, NULL, va);
+    return;
+  }
   if (NULL == our_hello)
     refresh_hello_task (NULL, NULL);
-  hello_size = GNUNET_HELLO_size(our_hello);
-  slen = strlen(va->transport_name) + 1;
-  tsize = sizeof(struct TransportPingMessage) + hello_size + va->addrlen + slen;
-  message_buf = GNUNET_malloc(tsize);
-  ping.challenge = htonl(va->challenge);
-  ping.header.size = htons(sizeof(struct TransportPingMessage) + slen + va->addrlen);
-  ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
-  memcpy(&ping.target, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
-  memcpy(message_buf, our_hello, hello_size);
-  memcpy(&message_buf[hello_size],
-         &ping,
-         sizeof(struct TransportPingMessage));
-  memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage)],
-         va->transport_name,
-         slen);
-  memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage) + slen],
-         &va[1],
-         va->addrlen);
+  hello_size = GNUNET_HELLO_size (our_hello);
+  slen = strlen (va->transport_name) + 1;
+  tsize =
+      sizeof (struct TransportPingMessage) + hello_size + va->addrlen + slen;
+  message_buf = GNUNET_malloc (tsize);
+  ping.challenge = htonl (va->challenge);
+  ping.header.size =
+      htons (sizeof (struct TransportPingMessage) + slen + va->addrlen);
+  ping.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
+  memcpy (&ping.target, &neighbour->id, sizeof (struct GNUNET_PeerIdentity));
+  memcpy (message_buf, our_hello, hello_size);
+  memcpy (&message_buf[hello_size],
+          &ping, sizeof (struct TransportPingMessage));
+  memcpy (&message_buf[hello_size + sizeof (struct TransportPingMessage)],
+          va->transport_name, slen);
+  memcpy (&message_buf
+          [hello_size + sizeof (struct TransportPingMessage) + slen], &va[1],
+          va->addrlen);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Performing validation of address `%s' via `%s' for peer `%4s' sending `%s' (%u bytes) and `%s' (%u bytes)\n",
-              (va->addrlen == 0)
-              ? "<inbound>"
-              : a2s (va->transport_name,
-                     (const void*) &va[1], va->addrlen),
-              va->transport_name,
-              GNUNET_i2s (&neighbour->id),
-              "HELLO", hello_size,
-              "PING", sizeof (struct TransportPingMessage) + va->addrlen + slen);
+              (va->addrlen == 0)
+              ? "<inbound>"
+              : a2s (va->transport_name,
+                     (const void *) &va[1], va->addrlen),
+              va->transport_name,
+              GNUNET_i2s (&neighbour->id),
+              "HELLO", hello_size,
+              "PING",
+              sizeof (struct TransportPingMessage) + va->addrlen + slen);
 #endif
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# PING messages sent for initial validation"),
-                            1,
-                            GNUNET_NO);
-  transmit_to_peer (NULL, peer_address,
-                    GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                    HELLO_VERIFICATION_TIMEOUT,
-                    message_buf, tsize,
-                    GNUNET_YES, neighbour);
+                            gettext_noop
+                            ("# PING messages sent for initial validation"), 1,
+                            GNUNET_NO);
+  transmit_to_peer (NULL, peer_address, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                    HELLO_VERIFICATION_TIMEOUT, message_buf, tsize, GNUNET_YES,
+                    neighbour);
   GNUNET_free (message_buf);
 }
 
@@ -4460,8 +4316,7 @@ static int
 run_validation (void *cls,
                 const char *tname,
                 struct GNUNET_TIME_Absolute expiration,
-                const void *addr,
-                uint16_t addrlen)
+                const void *addr, uint16_t addrlen)
 {
   struct CheckHelloValidatedContext *chvc = cls;
   struct GNUNET_PeerIdentity id;
@@ -4474,57 +4329,53 @@ run_validation (void *cls,
   GNUNET_assert (addr != NULL);
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# peer addresses scheduled for validation"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# peer addresses scheduled for validation"), 1,
+                            GNUNET_NO);
   tp = find_transport (tname);
   if (tp == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO |
-                  GNUNET_ERROR_TYPE_BULK,
-                  _
-                  ("Transport `%s' not loaded, will not try to validate peer address using this transport.\n"),
-                  tname);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# peer addresses not validated (plugin not available)"),
-                                1,
-                                GNUNET_NO);
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO |
+                GNUNET_ERROR_TYPE_BULK,
+                _
+                ("Transport `%s' not loaded, will not try to validate peer address using this transport.\n"),
+                tname);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# peer addresses not validated (plugin not available)"),
+                              1, GNUNET_NO);
+    return GNUNET_OK;
+  }
   /* check if this is one of our own addresses */
   oal = tp->addresses;
   while (NULL != oal)
+  {
+    if ((oal->addrlen == addrlen) && (0 == memcmp (&oal[1], addr, addrlen)))
     {
-      if ( (oal->addrlen == addrlen) &&
-           (0 == memcmp (&oal[1],
-                         addr,
-                         addrlen)) )
-        {
-          /* not plausible, this address is equivalent to our own address! */
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# peer addresses not validated (loopback)"),
-                                    1,
-                                    GNUNET_NO);
-          return GNUNET_OK;
-        }
-      oal = oal->next;
+      /* not plausible, this address is equivalent to our own address! */
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# peer addresses not validated (loopback)"),
+                                1, GNUNET_NO);
+      return GNUNET_OK;
     }
+    oal = oal->next;
+  }
   GNUNET_HELLO_get_key (chvc->hello, &pk);
   GNUNET_CRYPTO_hash (&pk,
                       sizeof (struct
                               GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
                       &id.hashPubKey);
 
-  if (is_blacklisted(&id, tp))
-    {
+  if (is_blacklisted (&id, tp))
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Attempted to validate blacklisted peer `%s' using `%s'!\n",
-                  GNUNET_i2s(&id),
-                  tname);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Attempted to validate blacklisted peer `%s' using `%s'!\n",
+                GNUNET_i2s (&id), tname);
 #endif
-      return GNUNET_OK;
-    }
+    return GNUNET_OK;
+  }
 
   caec.addr = addr;
   caec.addrlen = addrlen;
@@ -4532,49 +4383,43 @@ run_validation (void *cls,
   caec.tname = tname;
   caec.exists = GNUNET_NO;
   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
-                                         &check_address_exists,
-                                         &caec);
+                                         &check_address_exists, &caec);
   if (caec.exists == GNUNET_YES)
-    {
-      /* During validation attempts we will likely trigger the other
-         peer trying to validate our address which in turn will cause
-         it to send us its HELLO, so we expect to hit this case rather
-         frequently.  Only print something if we are very verbose. */
+  {
+    /* During validation attempts we will likely trigger the other
+     * peer trying to validate our address which in turn will cause
+     * it to send us its HELLO, so we expect to hit this case rather
+     * frequently.  Only print something if we are very verbose. */
 #if DEBUG_TRANSPORT > 1
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
-                  a2s (tname, addr, addrlen),
-                  tname,
-                  GNUNET_i2s (&id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
+                a2s (tname, addr, addrlen), tname, GNUNET_i2s (&id));
 #endif
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# peer addresses not validated (in progress)"),
-                                1,
-                                GNUNET_NO);
-      return GNUNET_OK;
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# peer addresses not validated (in progress)"),
+                              1, GNUNET_NO);
+    return GNUNET_OK;
+  }
   va = GNUNET_malloc (sizeof (struct ValidationEntry) + addrlen);
   va->chvc = chvc;
   chvc->ve_count++;
   va->transport_name = GNUNET_strdup (tname);
   va->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                             UINT_MAX);
-  va->send_time = GNUNET_TIME_absolute_get();
-  va->addr = (const void*) &va[1];
+  va->send_time = GNUNET_TIME_absolute_get ();
+  va->addr = (const void *) &va[1];
   memcpy (&va[1], addr, addrlen);
   va->addrlen = addrlen;
-  GNUNET_HELLO_get_key (chvc->hello,
-                        &va->publicKey);
+  GNUNET_HELLO_get_key (chvc->hello, &va->publicKey);
   va->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
-                                                   &timeout_hello_validation,
-                                                   va);
+                                                   &timeout_hello_validation,
+                                                   va);
   GNUNET_CONTAINER_multihashmap_put (validation_map,
-                                     &id.hashPubKey,
-                                     va,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  setup_peer_check_blacklist (&id, GNUNET_NO,
-                              &transmit_hello_and_ping,
-                              va);
+                                     &id.hashPubKey,
+                                     va,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  setup_peer_check_blacklist (&id, GNUNET_NO, &transmit_hello_and_ping, va);
   return GNUNET_OK;
 }
 
@@ -4601,111 +4446,98 @@ check_hello_validated (void *cls,
   struct NeighbourMapEntry *n;
 
   if (err_msg != NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Error in communication with PEERINFO service: %s\n"),
-                  err_msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Error in communication with PEERINFO service: %s\n"),
+                err_msg);
 #endif
-      /* return; */
+    /* return; */
   }
 
   if (peer == NULL)
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# outstanding peerinfo iterate requests"),
-                                -1,
-                                GNUNET_NO);
-      chvc->piter = NULL;
-      if (GNUNET_NO == chvc->hello_known)
-        {
-          /* notify PEERINFO about the peer now, so that we at least
-             have the public key if some other component needs it */
-          GNUNET_HELLO_get_key (chvc->hello, &pk);
-          GNUNET_CRYPTO_hash (&pk,
-                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                              &target.hashPubKey);
-          plain_hello = GNUNET_HELLO_create (&pk,
-                                             NULL,
-                                             NULL);
-          GNUNET_PEERINFO_add_peer (peerinfo, plain_hello);
-          GNUNET_free (plain_hello);
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# outstanding peerinfo iterate requests"), -1,
+                              GNUNET_NO);
+    chvc->piter = NULL;
+    if (GNUNET_NO == chvc->hello_known)
+    {
+      /* notify PEERINFO about the peer now, so that we at least
+       * have the public key if some other component needs it */
+      GNUNET_HELLO_get_key (chvc->hello, &pk);
+      GNUNET_CRYPTO_hash (&pk,
+                          sizeof (struct
+                                  GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                          &target.hashPubKey);
+      plain_hello = GNUNET_HELLO_create (&pk, NULL, NULL);
+      GNUNET_PEERINFO_add_peer (peerinfo, plain_hello);
+      GNUNET_free (plain_hello);
 #if DEBUG_TRANSPORT_HELLO
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "PEERINFO had no `%s' message for peer `%4s', full validation needed.\n",
-                      "HELLO",
-                      GNUNET_i2s (&target));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "PEERINFO had no `%s' message for peer `%4s', full validation needed.\n",
+                  "HELLO", GNUNET_i2s (&target));
 #endif
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# new HELLOs requiring full validation"),
-                                    1,
-                                    GNUNET_NO);
-          GNUNET_HELLO_iterate_addresses (chvc->hello,
-                                          GNUNET_NO,
-                                          &run_validation,
-                                          chvc);
-        }
-      else
-        {
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# duplicate HELLO (peer known)"),
-                                    1,
-                                    GNUNET_NO);
-        }
-      chvc->ve_count--;
-      if (chvc->ve_count == 0)
-        {
-          GNUNET_CONTAINER_DLL_remove (chvc_head,
-                                       chvc_tail,
-                                       chvc);
-          GNUNET_free (chvc);
-        }
-      return;
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# new HELLOs requiring full validation"), 1,
+                                GNUNET_NO);
+      GNUNET_HELLO_iterate_addresses (chvc->hello, GNUNET_NO, &run_validation,
+                                      chvc);
+    }
+    else
+    {
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop ("# duplicate HELLO (peer known)"),
+                                1, GNUNET_NO);
+    }
+    chvc->ve_count--;
+    if (chvc->ve_count == 0)
+    {
+      GNUNET_CONTAINER_DLL_remove (chvc_head, chvc_tail, chvc);
+      GNUNET_free (chvc);
     }
+    return;
+  }
   if (h == NULL)
     return;
 #if DEBUG_TRANSPORT_HELLO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "PEERINFO had `%s' message for peer `%4s', validating only new addresses.\n",
-              "HELLO",
-              GNUNET_i2s (peer));
+              "PEERINFO had `%s' message for peer `%4s', validating only new addresses.\n",
+              "HELLO", GNUNET_i2s (peer));
 #endif
   chvc->hello_known = GNUNET_YES;
   n = find_neighbour (peer);
   if (n != NULL)
-    {
+  {
 #if DEBUG_TRANSPORT_HELLO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Calling hello_iterate_addresses for %s!\n",
-                  GNUNET_i2s (peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Calling hello_iterate_addresses for %s!\n", GNUNET_i2s (peer));
 #endif
-      GNUNET_HELLO_iterate_addresses (h,
-                                      GNUNET_NO,
-                                      &add_to_foreign_address_list,
-                                      n);
-      try_transmission_to_peer (n);
-    }
+    GNUNET_HELLO_iterate_addresses (h,
+                                    GNUNET_NO, &add_to_foreign_address_list, n);
+    try_transmission_to_peer (n);
+  }
   else
-    {
+  {
 #if DEBUG_TRANSPORT_HELLO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No existing neighbor record for %s!\n",
-                  GNUNET_i2s (peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No existing neighbor record for %s!\n", GNUNET_i2s (peer));
 #endif
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# no existing neighbour record (validating HELLO)"),
-                                1,
-                                GNUNET_NO);
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# no existing neighbour record (validating HELLO)"),
+                              1, GNUNET_NO);
+  }
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# HELLO validations (update case)"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# HELLO validations (update case)"),
+                            1, GNUNET_NO);
   GNUNET_HELLO_iterate_new_addresses (chvc->hello,
-                                      h,
-                                      GNUNET_TIME_relative_to_absolute (HELLO_REVALIDATION_START_TIME),
-                                      &run_validation,
-                                      chvc);
+                                      h,
+                                      GNUNET_TIME_relative_to_absolute
+                                      (HELLO_REVALIDATION_START_TIME),
+                                      &run_validation, chvc);
 }
 
 
@@ -4726,6 +4558,7 @@ process_hello (struct TransportPlugin *plugin,
   struct CheckHelloValidatedContext *chvc;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
   struct NeighbourMapEntry *n;
+
 #if DEBUG_TRANSPORT_HELLO > 2
   char *my_id;
 #endif
@@ -4733,27 +4566,25 @@ process_hello (struct TransportPlugin *plugin,
   hsize = ntohs (message->size);
   if ((ntohs (message->type) != GNUNET_MESSAGE_TYPE_HELLO) ||
       (hsize < sizeof (struct GNUNET_MessageHeader)))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# HELLOs received for validation"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# HELLOs received for validation"),
+                            1, GNUNET_NO);
 
   hello = (const struct GNUNET_HELLO_Message *) message;
   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, &publicKey))
-    {
+  {
 #if DEBUG_TRANSPORT_HELLO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Unable to get public key from `%s' for `%4s'!\n",
-                  "HELLO",
-                  GNUNET_i2s (&target));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unable to get public key from `%s' for `%4s'!\n",
+                "HELLO", GNUNET_i2s (&target));
 #endif
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   GNUNET_CRYPTO_hash (&publicKey,
                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
                       &target.hashPubKey);
@@ -4761,111 +4592,103 @@ process_hello (struct TransportPlugin *plugin,
 #if DEBUG_TRANSPORT_HELLO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' message for `%4s'\n",
-              "HELLO",
-              GNUNET_i2s (&target));
+              "HELLO", GNUNET_i2s (&target));
 #endif
-  if (0 == memcmp (&my_identity,
-                   &target,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# HELLOs ignored for validation (is my own HELLO)"),
-                                1,
-                                GNUNET_NO);
-      return GNUNET_OK;
-    }
+  if (0 == memcmp (&my_identity, &target, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# HELLOs ignored for validation (is my own HELLO)"),
+                              1, GNUNET_NO);
+    return GNUNET_OK;
+  }
   n = find_neighbour (&target);
-  if ( (NULL != n) &&
-       (! n->public_key_valid) )
-    {
-      GNUNET_HELLO_get_key (hello, &n->publicKey);
-      n->public_key_valid = GNUNET_YES;
-    }
+  if ((NULL != n) && (!n->public_key_valid))
+  {
+    GNUNET_HELLO_get_key (hello, &n->publicKey);
+    n->public_key_valid = GNUNET_YES;
+  }
 
   /* check if load is too high before doing expensive stuff */
-  if (GNUNET_SCHEDULER_get_load (GNUNET_SCHEDULER_PRIORITY_BACKGROUND) > MAX_HELLO_LOAD)
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# HELLOs ignored due to high load"),
-                                1,
-                                GNUNET_NO);
+  if (GNUNET_SCHEDULER_get_load (GNUNET_SCHEDULER_PRIORITY_BACKGROUND) >
+      MAX_HELLO_LOAD)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# HELLOs ignored due to high load"), 1,
+                              GNUNET_NO);
 #if DEBUG_TRANSPORT_HELLO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Ignoring `%s' for `%4s', load too high.\n",
-                  "HELLO",
-                  GNUNET_i2s (&target));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Ignoring `%s' for `%4s', load too high.\n",
+                "HELLO", GNUNET_i2s (&target));
 #endif
-      return GNUNET_OK;
-    }
+    return GNUNET_OK;
+  }
 
 
   chvc = chvc_head;
   while (NULL != chvc)
+  {
+    if (GNUNET_HELLO_equals (hello,
+                             chvc->hello,
+                             GNUNET_TIME_absolute_get ()).abs_value > 0)
     {
-      if (GNUNET_HELLO_equals (hello,
-                               chvc->hello,
-                               GNUNET_TIME_absolute_get ()).abs_value > 0)
-        {
 #if DEBUG_TRANSPORT_HELLO > 2
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Received duplicate `%s' message for `%4s'; ignored\n",
-                      "HELLO",
-                      GNUNET_i2s (&target));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Received duplicate `%s' message for `%4s'; ignored\n",
+                  "HELLO", GNUNET_i2s (&target));
 #endif
-          return GNUNET_OK; /* validation already pending */
-        }
-      if (GNUNET_HELLO_size (hello) == GNUNET_HELLO_size (chvc->hello))
-        GNUNET_break (0 != memcmp (hello, chvc->hello,
-                                   GNUNET_HELLO_size(hello)));
-      chvc = chvc->next;
+      return GNUNET_OK;         /* validation already pending */
     }
+    if (GNUNET_HELLO_size (hello) == GNUNET_HELLO_size (chvc->hello))
+      GNUNET_break (0 != memcmp (hello, chvc->hello,
+                                 GNUNET_HELLO_size (hello)));
+    chvc = chvc->next;
+  }
 
 #if BREAK_TESTS
-  struct NeighbourMapEntry *temp_neighbor = find_neighbour(&target);
+  struct NeighbourMapEntry *temp_neighbor = find_neighbour (&target);
+
   if ((NULL != temp_neighbor))
-    {
-      fprintf(stderr, "Already know peer, ignoring hello\n");
-      return GNUNET_OK;
-    }
+  {
+    fprintf (stderr, "Already know peer, ignoring hello\n");
+    return GNUNET_OK;
+  }
 #endif
 
 #if DEBUG_TRANSPORT_HELLO > 2
   if (plugin != NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      my_id = GNUNET_strdup(GNUNET_i2s(plugin->env.my_identity));
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "%s: Starting validation of `%s' message for `%4s' via '%s' of size %u\n",
-                  my_id,
-                  "HELLO",
-                  GNUNET_i2s (&target),
-                  plugin->short_name,
-                  GNUNET_HELLO_size(hello));
-      GNUNET_free (my_id);
+    my_id = GNUNET_strdup (GNUNET_i2s (plugin->env.my_identity));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%s: Starting validation of `%s' message for `%4s' via '%s' of size %u\n",
+                my_id,
+                "HELLO",
+                GNUNET_i2s (&target),
+                plugin->short_name, GNUNET_HELLO_size (hello));
+    GNUNET_free (my_id);
 #endif
-    }
+  }
 #endif
   chvc = GNUNET_malloc (sizeof (struct CheckHelloValidatedContext) + hsize);
   chvc->ve_count = 1;
   chvc->hello = (const struct GNUNET_HELLO_Message *) &chvc[1];
   memcpy (&chvc[1], hello, hsize);
-  GNUNET_CONTAINER_DLL_insert (chvc_head,
-                               chvc_tail,
-                               chvc);
+  GNUNET_CONTAINER_DLL_insert (chvc_head, chvc_tail, chvc);
   /* finally, check if HELLO was previously validated
-     (continuation will then schedule actual validation) */
+   * (continuation will then schedule actual validation) */
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# peerinfo process hello iterate requests"),
-                            1,
+                            gettext_noop
+                            ("# peerinfo process hello iterate requests"), 1,
                             GNUNET_NO);
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# outstanding peerinfo iterate requests"),
-                            1,
+                            gettext_noop
+                            ("# outstanding peerinfo iterate requests"), 1,
                             GNUNET_NO);
-  chvc->piter = GNUNET_PEERINFO_iterate (peerinfo,
-                                         &target,
-                                         HELLO_VERIFICATION_TIMEOUT,
-                                         &check_hello_validated, chvc);
+  chvc->piter =
+      GNUNET_PEERINFO_iterate (peerinfo, &target, HELLO_VERIFICATION_TIMEOUT,
+                               &check_hello_validated, chvc);
   return GNUNET_OK;
 }
 
@@ -4894,144 +4717,134 @@ disconnect_neighbour (struct NeighbourMapEntry *n, int check)
   if (GNUNET_YES == n->in_disconnect)
     return;
   if (GNUNET_YES == check)
+  {
+    rpos = n->plugins;
+    while (NULL != rpos)
     {
-      rpos = n->plugins;
-      while (NULL != rpos)
+      peer_addresses = rpos->addresses;
+      while (peer_addresses != NULL)
+      {
+        /* Do not disconnect if: an address is connected or an inbound address exists */
+        if ((GNUNET_YES == peer_addresses->connected) ||
+            (peer_addresses->addrlen == 0))
         {
-          peer_addresses = rpos->addresses;
-          while (peer_addresses != NULL)
-            {
-              /* Do not disconnect if: an address is connected or an inbound address exists */
-              if ((GNUNET_YES == peer_addresses->connected) || (peer_addresses->addrlen == 0))
-                {
 #if DEBUG_TRANSPORT
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                              "NOT Disconnecting from `%4s', still have live address `%s'!\n",
-                              GNUNET_i2s (&n->id),
-                              a2s (peer_addresses->ready_list->plugin->short_name,
-                                   peer_addresses->addr,
-                                   peer_addresses->addrlen));
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "NOT Disconnecting from `%4s', still have live address `%s'!\n",
+                      GNUNET_i2s (&n->id),
+                      a2s (peer_addresses->ready_list->plugin->short_name,
+                           peer_addresses->addr, peer_addresses->addrlen));
 #endif
-                  return;             /* still connected */
-                }
-              peer_addresses = peer_addresses->next;
-            }
-          rpos = rpos->next;
+          return;               /* still connected */
         }
+        peer_addresses = peer_addresses->next;
+      }
+      rpos = rpos->next;
     }
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-              "Disconnecting from `%4s'\n",
-              GNUNET_i2s (&n->id));
+              "Disconnecting from `%4s'\n", GNUNET_i2s (&n->id));
 #endif
-  n->in_disconnect = GNUNET_YES; /* prevent recursive entry */
+  n->in_disconnect = GNUNET_YES;        /* prevent recursive entry */
 
   /* notify all clients about disconnect */
   if (GNUNET_YES == n->received_pong)
-    {
-      n->received_pong = GNUNET_NO;
-      notify_clients_disconnect (&n->id);
-    }
+  {
+    n->received_pong = GNUNET_NO;
+    notify_clients_disconnect (&n->id);
+  }
 #if HAVE_LIBGLPK
-  ats_modify_problem_state(ats, ATS_MODIFIED);
+  ats_modify_problem_state (ats, ATS_MODIFIED);
 #endif
   /* clean up all plugins, cancel connections and pending transmissions */
   while (NULL != (rpos = n->plugins))
+  {
+    n->plugins = rpos->next;
+    rpos->plugin->api->disconnect (rpos->plugin->api->cls, &n->id);
+    while (rpos->addresses != NULL)
     {
-      n->plugins = rpos->next;
-      rpos->plugin->api->disconnect (rpos->plugin->api->cls, &n->id);
-      while (rpos->addresses != NULL)
-        {
-          peer_pos = rpos->addresses;
-          rpos->addresses = peer_pos->next;
-          if (peer_pos->connected == GNUNET_YES)
-            {
-              GNUNET_STATISTICS_update (stats,
-                                        gettext_noop ("# connected addresses"),
-                                        -1,
-                                        GNUNET_NO);
-              peer_pos->connected = GNUNET_NO;
-            }
-          if (GNUNET_YES == peer_pos->validated)
-            GNUNET_STATISTICS_update (stats,
-                                      gettext_noop ("# peer addresses considered valid"),
-                                      -1,
-                                      GNUNET_NO);
-          if (GNUNET_SCHEDULER_NO_TASK != peer_pos->revalidate_task)
-            {
-              GNUNET_SCHEDULER_cancel (peer_pos->revalidate_task);
-              peer_pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
-            }
-          GNUNET_free (peer_pos->ressources);
-          peer_pos->ressources = NULL;
-          GNUNET_free (peer_pos->quality);
-          peer_pos->ressources = NULL;
-          GNUNET_free (peer_pos);
-        }
-      GNUNET_free (rpos);
+      peer_pos = rpos->addresses;
+      rpos->addresses = peer_pos->next;
+      if (peer_pos->connected == GNUNET_YES)
+      {
+        GNUNET_STATISTICS_update (stats,
+                                  gettext_noop ("# connected addresses"),
+                                  -1, GNUNET_NO);
+        peer_pos->connected = GNUNET_NO;
+      }
+      if (GNUNET_YES == peer_pos->validated)
+        GNUNET_STATISTICS_update (stats,
+                                  gettext_noop
+                                  ("# peer addresses considered valid"), -1,
+                                  GNUNET_NO);
+      if (GNUNET_SCHEDULER_NO_TASK != peer_pos->revalidate_task)
+      {
+        GNUNET_SCHEDULER_cancel (peer_pos->revalidate_task);
+        peer_pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
+      }
+      GNUNET_free (peer_pos->ressources);
+      peer_pos->ressources = NULL;
+      GNUNET_free (peer_pos->quality);
+      peer_pos->ressources = NULL;
+      GNUNET_free (peer_pos);
     }
+    GNUNET_free (rpos);
+  }
 
   /* free all messages on the queue */
   while (NULL != (mq = n->messages_head))
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes in message queue for other peers"),
-                                - (int64_t) mq->message_buf_size,
-                                GNUNET_NO);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes discarded due to disconnect"),
-                                mq->message_buf_size,
-                                GNUNET_NO);
-      GNUNET_CONTAINER_DLL_remove (n->messages_head,
-                                   n->messages_tail,
-                                   mq);
-      GNUNET_assert (0 == memcmp(&mq->neighbour_id,
-                                 &n->id,
-                                 sizeof(struct GNUNET_PeerIdentity)));
-      GNUNET_free (mq);
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# bytes in message queue for other peers"),
+                              -(int64_t) mq->message_buf_size, GNUNET_NO);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# bytes discarded due to disconnect"),
+                              mq->message_buf_size, GNUNET_NO);
+    GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
+    GNUNET_assert (0 == memcmp (&mq->neighbour_id,
+                                &n->id, sizeof (struct GNUNET_PeerIdentity)));
+    GNUNET_free (mq);
+  }
 
   while (NULL != (mq = n->cont_head))
-    {
+  {
 
-      GNUNET_CONTAINER_DLL_remove (n->cont_head,
-                                   n->cont_tail,
-                                   mq);
-      GNUNET_assert (0 == memcmp(&mq->neighbour_id,
-                                 &n->id,
-                                 sizeof(struct GNUNET_PeerIdentity)));
-      GNUNET_free (mq);
-    }
+    GNUNET_CONTAINER_DLL_remove (n->cont_head, n->cont_tail, mq);
+    GNUNET_assert (0 == memcmp (&mq->neighbour_id,
+                                &n->id, sizeof (struct GNUNET_PeerIdentity)));
+    GNUNET_free (mq);
+  }
 
   if (n->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (n->timeout_task);
-      n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (n->timeout_task);
+    n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (n->retry_task);
-      n->retry_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (n->retry_task);
+    n->retry_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (n->piter != NULL)
-    {
-      GNUNET_PEERINFO_iterate_cancel (n->piter);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# outstanding peerinfo iterate requests"),
-                                -1,
-                                GNUNET_NO);
-      n->piter = NULL;
-    }
+  {
+    GNUNET_PEERINFO_iterate_cancel (n->piter);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# outstanding peerinfo iterate requests"), -1,
+                              GNUNET_NO);
+    n->piter = NULL;
+  }
 
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_remove (neighbours,
-                                                       &n->id.hashPubKey,
-                                                       n));
+                 GNUNET_CONTAINER_multihashmap_remove (neighbours,
+                                                       &n->id.hashPubKey, n));
   /* finally, free n itself */
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# active neighbours"),
-                            -1,
-                            GNUNET_NO);
+                            gettext_noop ("# active neighbours"),
+                            -1, GNUNET_NO);
   GNUNET_free_non_null (n->pre_connect_message_buffer);
   GNUNET_free (n);
 }
@@ -5043,13 +4856,12 @@ disconnect_neighbour (struct NeighbourMapEntry *n, int check)
  */
 static int
 handle_ping (void *cls, const struct GNUNET_MessageHeader *message,
-             const struct GNUNET_PeerIdentity *peer,
-             struct Session *session,
-             const char *sender_address,
-             uint16_t sender_address_len)
+             const struct GNUNET_PeerIdentity *peer,
+             struct Session *session,
+             const char *sender_address, uint16_t sender_address_len)
 {
   struct TransportPlugin *plugin = cls;
-  struct SessionHeader *session_header = (struct SessionHeader*) session;
+  struct SessionHeader *session_header = (struct SessionHeader *) session;
   struct TransportPingMessage *ping;
   struct TransportPongMessage *pong;
   struct NeighbourMapEntry *n;
@@ -5062,266 +4874,252 @@ handle_ping (void *cls, const struct GNUNET_MessageHeader *message,
   int did_pong;
 
   if (ntohs (message->size) < sizeof (struct TransportPingMessage))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
 
   ping = (struct TransportPingMessage *) message;
   if (0 != memcmp (&ping->target,
                    plugin->env.my_identity,
                    sizeof (struct GNUNET_PeerIdentity)))
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Received `%s' message from `%s' destined for `%s' which is not me!\n"),
-                  "PING",
-                  (sender_address != NULL)
-                  ? a2s (plugin->short_name,
-                         (const struct sockaddr *)sender_address,
-                         sender_address_len)
-                  : "<inbound>",
-                  GNUNET_i2s (&ping->target));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _
+                ("Received `%s' message from `%s' destined for `%s' which is not me!\n"),
+                "PING", (sender_address != NULL) ? a2s (plugin->short_name,
+                                                        (const struct sockaddr
+                                                         *) sender_address,
+                                                        sender_address_len) :
+                "<inbound>", GNUNET_i2s (&ping->target));
 #endif
-      return GNUNET_SYSERR;
-    }
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_PING_PONG
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-              "Processing `%s' from `%s'\n",
-              "PING",
-              (sender_address != NULL)
-              ? a2s (plugin->short_name,
-                     (const struct sockaddr *)sender_address,
-                     sender_address_len)
-              : "<inbound>");
+              "Processing `%s' from `%s'\n",
+              "PING",
+              (sender_address != NULL)
+              ? a2s (plugin->short_name,
+                     (const struct sockaddr *) sender_address,
+                     sender_address_len) : "<inbound>");
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# PING messages received"),
-                            1,
-                            GNUNET_NO);
-  addr = (const char*) &ping[1];
+                            gettext_noop ("# PING messages received"),
+                            1, GNUNET_NO);
+  addr = (const char *) &ping[1];
   alen = ntohs (message->size) - sizeof (struct TransportPingMessage);
   slen = strlen (plugin->short_name) + 1;
   if (alen == 0)
+  {
+    /* peer wants to confirm that we have an outbound connection to him */
+    if (session == NULL)
     {
-      /* peer wants to confirm that we have an outbound connection to him */
-      if (session == NULL)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      _("Refusing to create PONG since I do not have a session with `%s'.\n"),
-                      GNUNET_i2s (peer));
-          return GNUNET_SYSERR;
-        }
-      /* FIXME-urg: the use of 'sender_address' in the code below is doubly-wrong:
-        1) it is NULL when we need to have a real value
-        2) it is documented to be the address of the sender (source-IP), where
-        what we actually want is our LISTEN IP (what we 'bound' to); which we don't even
-        have...
-      */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Creating PONG indicating that we received a connection at our address `%s' from `%s'.\n",
-                  a2s (plugin->short_name,
-                       sender_address,
-                       sender_address_len),                    
-                  GNUNET_i2s (peer));
-
-      pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + sender_address_len + slen);
-      pong->header.size = htons (sizeof (struct TransportPongMessage) + sender_address_len + slen);
-      pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
-      pong->purpose.size =
-        htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
-               sizeof (uint32_t) +
-               sizeof (struct GNUNET_TIME_AbsoluteNBO) +
-               sizeof (struct GNUNET_PeerIdentity) + sender_address_len + slen);
-      pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING);
-      pong->challenge = ping->challenge;
-      pong->addrlen = htonl(sender_address_len + slen);
-      memcpy(&pong->pid,
-             peer,
-             sizeof(struct GNUNET_PeerIdentity));
-      memcpy (&pong[1],
-              plugin->short_name,
-              slen);
-      if ((sender_address!=NULL) && (sender_address_len > 0))
-                  memcpy (&((char*)&pong[1])[slen],
-                          sender_address,
-                          sender_address_len);
-      if (GNUNET_TIME_absolute_get_remaining (session_header->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4)
-        {
-          /* create / update cached sig */
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _
+                  ("Refusing to create PONG since I do not have a session with `%s'.\n"),
+                  GNUNET_i2s (peer));
+      return GNUNET_SYSERR;
+    }
+    /* FIXME-urg: the use of 'sender_address' in the code below is doubly-wrong:
+     * 1) it is NULL when we need to have a real value
+     * 2) it is documented to be the address of the sender (source-IP), where
+     * what we actually want is our LISTEN IP (what we 'bound' to); which we don't even
+     * have...
+     */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Creating PONG indicating that we received a connection at our address `%s' from `%s'.\n",
+                a2s (plugin->short_name,
+                     sender_address, sender_address_len), GNUNET_i2s (peer));
+
+    pong =
+        GNUNET_malloc (sizeof (struct TransportPongMessage) +
+                       sender_address_len + slen);
+    pong->header.size =
+        htons (sizeof (struct TransportPongMessage) + sender_address_len +
+               slen);
+    pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
+    pong->purpose.size =
+        htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
+               sizeof (uint32_t) +
+               sizeof (struct GNUNET_TIME_AbsoluteNBO) +
+               sizeof (struct GNUNET_PeerIdentity) + sender_address_len + slen);
+    pong->purpose.purpose =
+        htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING);
+    pong->challenge = ping->challenge;
+    pong->addrlen = htonl (sender_address_len + slen);
+    memcpy (&pong->pid, peer, sizeof (struct GNUNET_PeerIdentity));
+    memcpy (&pong[1], plugin->short_name, slen);
+    if ((sender_address != NULL) && (sender_address_len > 0))
+      memcpy (&((char *) &pong[1])[slen], sender_address, sender_address_len);
+    if (GNUNET_TIME_absolute_get_remaining
+        (session_header->pong_sig_expires).rel_value <
+        PONG_SIGNATURE_LIFETIME.rel_value / 4)
+    {
+      /* create / update cached sig */
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Creating PONG signature to indicate active connection.\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Creating PONG signature to indicate active connection.\n");
 #endif
-          session_header->pong_sig_expires = GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
-          pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
-          GNUNET_assert (GNUNET_OK ==
-                         GNUNET_CRYPTO_rsa_sign (my_private_key,
-                                                 &pong->purpose,
-                                                 &session_header->pong_signature));
-        }
-      else
-        {
-          pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
-        }
-      memcpy (&pong->signature,
-              &session_header->pong_signature,
-              sizeof (struct GNUNET_CRYPTO_RsaSignature));
+      session_header->pong_sig_expires =
+          GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
+      pong->expiration =
+          GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_rsa_sign (my_private_key, &pong->purpose,
+                                             &session_header->pong_signature));
+    }
+    else
+    {
+      pong->expiration =
+          GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
+    }
+    memcpy (&pong->signature,
+            &session_header->pong_signature,
+            sizeof (struct GNUNET_CRYPTO_RsaSignature));
 
 
-    }
+  }
   else
+  {
+    /* peer wants to confirm that this is one of our addresses */
+    addr += slen;
+    alen -= slen;
+    if (GNUNET_OK != plugin->api->check_address (plugin->api->cls, addr, alen))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _
+                  ("Not confirming PING with address `%s' since I cannot confirm having this address.\n"),
+                  a2s (plugin->short_name, addr, alen));
+      return GNUNET_NO;
+    }
+    oal = plugin->addresses;
+    while (NULL != oal)
     {
-      /* peer wants to confirm that this is one of our addresses */
-      addr += slen;
-      alen -= slen;
-      if (GNUNET_OK !=
-          plugin->api->check_address (plugin->api->cls,
-                                      addr,
-                                      alen))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      _("Not confirming PING with address `%s' since I cannot confirm having this address.\n"),
-                      a2s (plugin->short_name,
-                           addr,
-                           alen));
-          return GNUNET_NO;
-        }
-      oal = plugin->addresses;
-      while (NULL != oal)
-        {
-          if ( (oal->addrlen == alen) &&
-               (0 == memcmp (addr,
-                             &oal[1],
-                             alen)) )
-            break;
-          oal = oal->next;
-        }
-      pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + alen + slen);
-      pong->header.size = htons (sizeof (struct TransportPongMessage) + alen + slen);
-      pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
-      pong->purpose.size =
-        htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
-               sizeof (uint32_t) +
-               sizeof (struct GNUNET_TIME_AbsoluteNBO) +
-               sizeof (struct GNUNET_PeerIdentity) + alen + slen);
-      pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN);
-      pong->challenge = ping->challenge;
-      pong->addrlen = htonl(alen + slen);
-      memcpy(&pong->pid,
-             &my_identity,
-             sizeof(struct GNUNET_PeerIdentity));
-      memcpy (&pong[1], plugin->short_name, slen);
-      memcpy (&((char*)&pong[1])[slen], addr, alen);
-      if ( (oal != NULL) &&
-           (GNUNET_TIME_absolute_get_remaining (oal->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4) )
-        {
-          /* create / update cached sig */
+      if ((oal->addrlen == alen) && (0 == memcmp (addr, &oal[1], alen)))
+        break;
+      oal = oal->next;
+    }
+    pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + alen + slen);
+    pong->header.size =
+        htons (sizeof (struct TransportPongMessage) + alen + slen);
+    pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
+    pong->purpose.size =
+        htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
+               sizeof (uint32_t) +
+               sizeof (struct GNUNET_TIME_AbsoluteNBO) +
+               sizeof (struct GNUNET_PeerIdentity) + alen + slen);
+    pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN);
+    pong->challenge = ping->challenge;
+    pong->addrlen = htonl (alen + slen);
+    memcpy (&pong->pid, &my_identity, sizeof (struct GNUNET_PeerIdentity));
+    memcpy (&pong[1], plugin->short_name, slen);
+    memcpy (&((char *) &pong[1])[slen], addr, alen);
+    if ((oal != NULL) &&
+        (GNUNET_TIME_absolute_get_remaining (oal->pong_sig_expires).rel_value <
+         PONG_SIGNATURE_LIFETIME.rel_value / 4))
+    {
+      /* create / update cached sig */
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Creating PONG signature to indicate ownership.\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Creating PONG signature to indicate ownership.\n");
 #endif
-          oal->pong_sig_expires = GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
-          pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
-          GNUNET_assert (GNUNET_OK ==
-                         GNUNET_CRYPTO_rsa_sign (my_private_key,
-                                                 &pong->purpose,
-                                                 &oal->pong_signature));
-          memcpy (&pong->signature,
-                  &oal->pong_signature,
-                  sizeof (struct GNUNET_CRYPTO_RsaSignature));
-        }
-      else if (oal == NULL)
-        {
-          /* not using cache (typically DV-only) */
-          pong->expiration = GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME));
-          GNUNET_assert (GNUNET_OK ==
-                         GNUNET_CRYPTO_rsa_sign (my_private_key,
-                                                 &pong->purpose,
-                                                 &pong->signature));
-        }
-      else
-        {
-          /* can used cached version */
-          pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
-          memcpy (&pong->signature,
-                  &oal->pong_signature,
-                  sizeof (struct GNUNET_CRYPTO_RsaSignature));
-        }
+      oal->pong_sig_expires =
+          GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
+      pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_rsa_sign (my_private_key,
+                                             &pong->purpose,
+                                             &oal->pong_signature));
+      memcpy (&pong->signature,
+              &oal->pong_signature, sizeof (struct GNUNET_CRYPTO_RsaSignature));
+    }
+    else if (oal == NULL)
+    {
+      /* not using cache (typically DV-only) */
+      pong->expiration =
+          GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute
+                                     (PONG_SIGNATURE_LIFETIME));
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_rsa_sign (my_private_key, &pong->purpose,
+                                             &pong->signature));
+    }
+    else
+    {
+      /* can used cached version */
+      pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
+      memcpy (&pong->signature,
+              &oal->pong_signature, sizeof (struct GNUNET_CRYPTO_RsaSignature));
     }
-  n = find_neighbour(peer);
+  }
+  n = find_neighbour (peer);
   GNUNET_assert (n != NULL);
   did_pong = GNUNET_NO;
   /* first try reliable response transmission */
   rl = n->plugins;
   while (rl != NULL)
-    {
-      fal = rl->addresses;
-      while (fal != NULL)
-        {
-          if (-1 != rl->plugin->api->send (rl->plugin->api->cls,
-                                           peer,
-                                           (const char*) pong,
-                                           ntohs (pong->header.size),
-                                           TRANSPORT_PONG_PRIORITY,
-                                           HELLO_VERIFICATION_TIMEOUT,
-                                           fal->session,
-                                           fal->addr,
-                                           fal->addrlen,
-                                           GNUNET_SYSERR,
-                                           NULL, NULL))
-            {
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Transmitted PONG to `%s' via reliable mechanism\n",
-                          GNUNET_i2s (peer));
-              /* done! */
-              GNUNET_STATISTICS_update (stats,
-                                        gettext_noop ("# PONGs unicast via reliable transport"),
-                                        1,
-                                        GNUNET_NO);
-              GNUNET_free (pong);
-              return GNUNET_OK;
-            }
-          did_pong = GNUNET_YES;
-          fal = fal->next;
-        }
-      rl = rl->next;
+  {
+    fal = rl->addresses;
+    while (fal != NULL)
+    {
+      if (-1 != rl->plugin->api->send (rl->plugin->api->cls,
+                                       peer,
+                                       (const char *) pong,
+                                       ntohs (pong->header.size),
+                                       TRANSPORT_PONG_PRIORITY,
+                                       HELLO_VERIFICATION_TIMEOUT,
+                                       fal->session,
+                                       fal->addr,
+                                       fal->addrlen, GNUNET_SYSERR, NULL, NULL))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Transmitted PONG to `%s' via reliable mechanism\n",
+                    GNUNET_i2s (peer));
+        /* done! */
+        GNUNET_STATISTICS_update (stats,
+                                  gettext_noop
+                                  ("# PONGs unicast via reliable transport"), 1,
+                                  GNUNET_NO);
+        GNUNET_free (pong);
+        return GNUNET_OK;
+      }
+      did_pong = GNUNET_YES;
+      fal = fal->next;
     }
+    rl = rl->next;
+  }
   /* no reliable method found, do multicast */
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# PONGs multicast to all available addresses"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# PONGs multicast to all available addresses"), 1,
+                            GNUNET_NO);
   rl = n->plugins;
   while (rl != NULL)
+  {
+    fal = rl->addresses;
+    while (fal != NULL)
     {
-      fal = rl->addresses;
-      while (fal != NULL)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Transmitting PONG to `%s' via unreliable mechanism `%s':%s\n",
-                      GNUNET_i2s (peer),
-                      a2s (rl->plugin->short_name,
-                           fal->addr,
-                           fal->addrlen),
-                      rl->plugin->short_name);
-          transmit_to_peer(NULL, fal,
-                           TRANSPORT_PONG_PRIORITY,
-                           HELLO_VERIFICATION_TIMEOUT,
-                           (const char *)pong,
-                           ntohs(pong->header.size),
-                           GNUNET_YES,
-                           n);
-          did_pong = GNUNET_YES;
-          fal = fal->next;
-        }
-      rl = rl->next;
-    }
-  GNUNET_free(pong);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Transmitting PONG to `%s' via unreliable mechanism `%s':%s\n",
+                  GNUNET_i2s (peer),
+                  a2s (rl->plugin->short_name,
+                       fal->addr, fal->addrlen), rl->plugin->short_name);
+      transmit_to_peer (NULL, fal,
+                        TRANSPORT_PONG_PRIORITY,
+                        HELLO_VERIFICATION_TIMEOUT,
+                        (const char *) pong,
+                        ntohs (pong->header.size), GNUNET_YES, n);
+      did_pong = GNUNET_YES;
+      fal = fal->next;
+    }
+    rl = rl->next;
+  }
+  GNUNET_free (pong);
   if (GNUNET_YES != did_pong)
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Could not send PONG to `%s': no address available\n"),
-                GNUNET_i2s (peer));
+                _("Could not send PONG to `%s': no address available\n"),
+                GNUNET_i2s (peer));
   return GNUNET_OK;
 }
 
@@ -5350,8 +5148,7 @@ plugin_env_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
                     const struct GNUNET_TRANSPORT_ATS_Information *ats_data,
                     uint32_t ats_count,
                     struct Session *session,
-                    const char *sender_address,
-                    uint16_t sender_address_len)
+                    const char *sender_address, uint16_t sender_address_len)
 {
   struct TransportPlugin *plugin = cls;
   struct ReadyList *service_context;
@@ -5362,14 +5159,12 @@ plugin_env_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
   uint32_t distance;
   int c;
 
-  if (0 == memcmp (peer,
-                   &my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      /* refuse to receive from myself */
-      GNUNET_break (0); 
-      return GNUNET_TIME_UNIT_FOREVER_REL;
-    }
+  if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    /* refuse to receive from myself */
+    GNUNET_break (0);
+    return GNUNET_TIME_UNIT_FOREVER_REL;
+  }
   if (is_blacklisted (peer, plugin))
     return GNUNET_TIME_UNIT_FOREVER_REL;
   n = find_neighbour (peer);
@@ -5382,157 +5177,160 @@ plugin_env_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
   peer_address = NULL;
   distance = 1;
 
-  for (c=0; c<ats_count; c++)
-    if (ntohl(ats_data[c].type) == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
-      distance = ntohl(ats_data[c].value);
+  for (c = 0; c < ats_count; c++)
+    if (ntohl (ats_data[c].type) == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
+      distance = ntohl (ats_data[c].value);
 
 
   if (message != NULL)
-    {
-      if ( (session != NULL) ||
-           (sender_address != NULL) )
-        peer_address = add_peer_address (n,
-                                         plugin->short_name,
-                                         session,
-                                         sender_address,
-                                         sender_address_len);
-      if (peer_address != NULL)
-        {
-          update_addr_ats(peer_address, ats_data, ats_count);
-          update_addr_value(peer_address, distance, GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
-          
-          peer_address->distance = distance;
-          if (GNUNET_YES == peer_address->validated)
-          {
-            mark_address_connected (peer_address);
-            schedule_next_ping (peer_address);
-          }
-          else
-          {
+  {
+    if ((session != NULL) || (sender_address != NULL))
+      peer_address = add_peer_address (n,
+                                       plugin->short_name,
+                                       session,
+                                       sender_address, sender_address_len);
+    if (peer_address != NULL)
+    {
+      update_addr_ats (peer_address, ats_data, ats_count);
+      update_addr_value (peer_address, distance,
+                         GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
+
+      peer_address->distance = distance;
+      if (GNUNET_YES == peer_address->validated)
+      {
+        mark_address_connected (peer_address);
+        schedule_next_ping (peer_address);
+      }
+      else
+      {
 #if DEBUG_TRANSPORT
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                        "New address is unvalidated, trying to validate it now\n");
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "New address is unvalidated, trying to validate it now\n");
 #endif
-             if (peer_address->revalidate_task != GNUNET_SCHEDULER_NO_TASK)
-             {
-               GNUNET_SCHEDULER_cancel (peer_address->revalidate_task);
-               peer_address->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
-             }
-             peer_address->revalidate_task = GNUNET_SCHEDULER_add_now (&send_periodic_ping, peer_address);
-
-          }
-          peer_address->timeout
-            = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
-        }
-      /* update traffic received amount ... */
-      msize = ntohs (message->size);
+        if (peer_address->revalidate_task != GNUNET_SCHEDULER_NO_TASK)
+        {
+          GNUNET_SCHEDULER_cancel (peer_address->revalidate_task);
+          peer_address->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
+        }
+        peer_address->revalidate_task =
+            GNUNET_SCHEDULER_add_now (&send_periodic_ping, peer_address);
 
+      }
+      peer_address->timeout
+          =
+          GNUNET_TIME_relative_to_absolute
+          (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+    }
+    /* update traffic received amount ... */
+    msize = ntohs (message->size);
+
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# bytes received from other peers"), msize,
+                              GNUNET_NO);
+    n->distance = distance;
+    n->peer_timeout =
+        GNUNET_TIME_relative_to_absolute
+        (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+    GNUNET_SCHEDULER_cancel (n->timeout_task);
+    n->timeout_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                      &neighbour_timeout_task, n);
+    if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
+    {
+      /* dropping message due to frequent inbound volume violations! */
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING |
+                  GNUNET_ERROR_TYPE_BULK,
+                  _
+                  ("Dropping incoming message due to repeated bandwidth quota (%u b/s) violations (total of %u).\n"),
+                  n->in_tracker.available_bytes_per_s__,
+                  n->quota_violation_count);
       GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes received from other peers"),
-                                msize,
-                                GNUNET_NO);
-      n->distance = distance;
-      n->peer_timeout =
-        GNUNET_TIME_relative_to_absolute
-        (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
-      GNUNET_SCHEDULER_cancel (n->timeout_task);
-      n->timeout_task =
-        GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                                      &neighbour_timeout_task, n);
-      if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
-        {
-          /* dropping message due to frequent inbound volume violations! */
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING |
-                      GNUNET_ERROR_TYPE_BULK,
-                      _
-                      ("Dropping incoming message due to repeated bandwidth quota (%u b/s) violations (total of %u).\n"),
-                      n->in_tracker.available_bytes_per_s__,
-                      n->quota_violation_count);
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# bandwidth quota violations by other peers"),
-                                    1,
-                                    GNUNET_NO);
-          return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
-        }
-    if ((ntohs(message->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ATS) &&
-        (ntohs(message->size) == (sizeof (struct GNUNET_MessageHeader) + sizeof (uint32_t))))
-      {
+                                gettext_noop
+                                ("# bandwidth quota violations by other peers"),
+                                1, GNUNET_NO);
+      return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
+    }
+    if ((ntohs (message->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ATS) &&
+        (ntohs (message->size) ==
+         (sizeof (struct GNUNET_MessageHeader) + sizeof (uint32_t))))
+    {
 #if HAVE_LIBGLPK
-        uint32_t value =  ntohl(*((uint32_t *) &message[1]));
-        //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GNUNET_MESSAGE_TYPE_TRANSPORT_ATS: %i \n", value);
-        /* Force ressource and quality update */
-        if ((value == 4) && (ats != NULL))
-            ats_modify_problem_state(ats, ATS_QUALITY_COST_UPDATED);
-        /* Force cost update */
-        if ((value == 3) && (ats != NULL))
-          ats_modify_problem_state(ats, ATS_COST_UPDATED);
-        /* Force quality update */
-        if ((value == 2) && (ats != NULL))
-          ats_modify_problem_state(ats, ATS_QUALITY_UPDATED);
-        /* Force full rebuild */
-        if ((value == 1) && (ats != NULL))
-          ats_modify_problem_state(ats, ATS_MODIFIED);
+      uint32_t value = ntohl (*((uint32_t *) & message[1]));
+
+      //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GNUNET_MESSAGE_TYPE_TRANSPORT_ATS: %i \n", value);
+      /* Force ressource and quality update */
+      if ((value == 4) && (ats != NULL))
+        ats_modify_problem_state (ats, ATS_QUALITY_COST_UPDATED);
+      /* Force cost update */
+      if ((value == 3) && (ats != NULL))
+        ats_modify_problem_state (ats, ATS_COST_UPDATED);
+      /* Force quality update */
+      if ((value == 2) && (ats != NULL))
+        ats_modify_problem_state (ats, ATS_QUALITY_UPDATED);
+      /* Force full rebuild */
+      if ((value == 1) && (ats != NULL))
+        ats_modify_problem_state (ats, ATS_MODIFIED);
 #endif
-      }
-    
+    }
+
 #if DEBUG_PING_PONG
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received message of type %u and size %u from `%4s', sending to all clients.\n",
-                ntohs (message->type),
-                ntohs (message->size),
-                GNUNET_i2s (peer));
+                "Received message of type %u and size %u from `%4s', sending to all clients.\n",
+                ntohs (message->type),
+                ntohs (message->size), GNUNET_i2s (peer));
 #endif
-      switch (ntohs (message->type))
-        {
-        case GNUNET_MESSAGE_TYPE_HELLO:
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# HELLO messages received from other peers"),
-                                    1,
-                                    GNUNET_NO);
-          process_hello (plugin, message);
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
-          handle_ping (plugin, message, peer, session, sender_address, sender_address_len);
-          if (GNUNET_YES != n->received_pong)
-            transmit_plain_ping (n);
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
-          handle_pong (plugin, message, peer, sender_address, sender_address_len);
-          break;
-        case GNUNET_MESSAGE_TYPE_TRANSPORT_ATS:
-          break;
-        default:
-          handle_payload_message (message, n);
-          break;
-        }
+    switch (ntohs (message->type))
+    {
+    case GNUNET_MESSAGE_TYPE_HELLO:
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# HELLO messages received from other peers"),
+                                1, GNUNET_NO);
+      process_hello (plugin, message);
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
+      handle_ping (plugin, message, peer, session, sender_address,
+                   sender_address_len);
+      if (GNUNET_YES != n->received_pong)
+        transmit_plain_ping (n);
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
+      handle_pong (plugin, message, peer, sender_address, sender_address_len);
+      break;
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_ATS:
+      break;
+    default:
+      handle_payload_message (message, n);
+      break;
     }
+  }
   ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 0);
   if (ret.rel_value > 0)
-    {
-#if DEBUG_TRANSPORT 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Throttling read (%llu bytes excess at %u b/s), waiting %llu ms before reading more.\n",
-                  (unsigned long long) n->in_tracker.consumption_since_last_update__,
-                  (unsigned int) n->in_tracker.available_bytes_per_s__,
-                  (unsigned long long) ret.rel_value);
+  {
+#if DEBUG_TRANSPORT
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Throttling read (%llu bytes excess at %u b/s), waiting %llu ms before reading more.\n",
+                (unsigned long long) n->
+                in_tracker.consumption_since_last_update__,
+                (unsigned int) n->in_tracker.available_bytes_per_s__,
+                (unsigned long long) ret.rel_value);
 #endif
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# ms throttling suggested"),
-                                (int64_t) ret.rel_value,
-                                GNUNET_NO);
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# ms throttling suggested"),
+                              (int64_t) ret.rel_value, GNUNET_NO);
+  }
   return ret;
 }
 
 
 static int
 notify_client_about_neighbour (void *cls,
-                               const GNUNET_HashCode *key,
-                               void *value)
+                               const GNUNET_HashCode * key, void *value)
 {
   struct TransportClient *c = cls;
   struct NeighbourMapEntry *n = value;
-  struct ConnectInfoMessage * cim;
+  struct ConnectInfoMessage *cim;
   uint32_t ats_count;
   size_t size;
 
@@ -5540,23 +5338,25 @@ notify_client_about_neighbour (void *cls,
     return GNUNET_OK;
 
   ats_count = 2;
-  size  = sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+  size =
+      sizeof (struct ConnectInfoMessage) +
+      ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
   GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   cim = GNUNET_malloc (size);
   cim->header.size = htons (size);
   cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
-  cim->ats_count = htonl(ats_count);
+  cim->ats_count = htonl (ats_count);
   (&(cim->ats))[2].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
-  (&(cim->ats))[2].value = htonl (0); 
+  (&(cim->ats))[2].value = htonl (0);
   if (GNUNET_YES == n->received_pong)
-    {
-      (&cim->ats)[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
-      (&cim->ats)[0].value = htonl (n->distance);
-      (&cim->ats)[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
-      (&cim->ats)[1].value = htonl ((uint32_t) n->latency.rel_value);
-      cim->id = n->id;
-      transmit_to_client (c, &cim->header, GNUNET_NO);
-    }
+  {
+    (&cim->ats)[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
+    (&cim->ats)[0].value = htonl (n->distance);
+    (&cim->ats)[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
+    (&cim->ats)[1].value = htonl ((uint32_t) n->latency.rel_value);
+    cim->id = n->id;
+    transmit_to_client (c, &cim->header, GNUNET_NO);
+  }
   GNUNET_free (cim);
   return GNUNET_OK;
 }
@@ -5578,60 +5378,59 @@ handle_start (void *cls,
   const struct StartMessage *start;
   struct TransportClient *c;
 
-  start = (const struct StartMessage*) message;
+  start = (const struct StartMessage *) message;
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' request from client\n", "START");
 #endif
   c = clients;
   while (c != NULL)
+  {
+    if (c->client == client)
     {
-      if (c->client == client)
-        {
-          /* client already on our list! */
-          GNUNET_break (0);
-          GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-          return;
-        }
-      c = c->next;
-    }
-  if ( (GNUNET_NO != ntohl (start->do_check)) &&
-       (0 != memcmp (&start->self,
-                     &my_identity,
-                     sizeof (struct GNUNET_PeerIdentity))) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Rejecting control connection from peer `%s', which is not me!\n"),
-                  GNUNET_i2s (&start->self));
+      /* client already on our list! */
+      GNUNET_break (0);
       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
       return;
     }
+    c = c->next;
+  }
+  if ((GNUNET_NO != ntohl (start->do_check)) &&
+      (0 != memcmp (&start->self,
+                    &my_identity, sizeof (struct GNUNET_PeerIdentity))))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Rejecting control connection from peer `%s', which is not me!\n"),
+                GNUNET_i2s (&start->self));
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   c = GNUNET_malloc (sizeof (struct TransportClient));
   c->next = clients;
   clients = c;
   c->client = client;
   if (our_hello != NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending our own `%s' to new client\n", "HELLO");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending our own `%s' to new client\n", "HELLO");
 #endif
-      transmit_to_client (c,
-                          (const struct GNUNET_MessageHeader *) our_hello,
-                          GNUNET_NO);
-      /* tell new client about all existing connections */
-      GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                             &notify_client_about_neighbour,
-                                             c);
-    }
+    transmit_to_client (c,
+                        (const struct GNUNET_MessageHeader *) our_hello,
+                        GNUNET_NO);
+    /* tell new client about all existing connections */
+    GNUNET_CONTAINER_multihashmap_iterate (neighbours,
+                                           &notify_client_about_neighbour, c);
+  }
   else
-    {
+  {
 #if DEBUG_TRANSPORT_HELLO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No HELLO created yet, will transmit HELLO to client later!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No HELLO created yet, will transmit HELLO to client later!\n");
 #endif
-      refresh_hello ();
-    }
+    refresh_hello ();
+  }
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -5651,9 +5450,8 @@ handle_hello (void *cls,
   int ret;
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# HELLOs received from clients"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# HELLOs received from clients"),
+                            1, GNUNET_NO);
   ret = process_hello (NULL, message);
   GNUNET_SERVER_receive_done (client, ret);
 }
@@ -5694,8 +5492,7 @@ struct TransmitClientMessageContext
  * @param n destination, or NULL on error (in that case, drop the message)
  */
 static void
-transmit_client_message (void *cls,
-                         struct NeighbourMapEntry *n)
+transmit_client_message (void *cls, struct NeighbourMapEntry *n)
 {
   struct TransmitClientMessageContext *tcmc = cls;
   struct TransportClient *tc;
@@ -5705,12 +5502,11 @@ transmit_client_message (void *cls,
     tc = tc->next;
 
   if (n != NULL)
-    {
-      transmit_to_peer (tc, NULL, tcmc->priority,
-                        GNUNET_TIME_absolute_get_remaining (tcmc->timeout),
-                        (char *)&tcmc[1],
-                        tcmc->msize, GNUNET_NO, n);
-    }
+  {
+    transmit_to_peer (tc, NULL, tcmc->priority,
+                      GNUNET_TIME_absolute_get_remaining (tcmc->timeout),
+                      (char *) &tcmc[1], tcmc->msize, GNUNET_NO, n);
+  }
   GNUNET_SERVER_receive_done (tcmc->client, GNUNET_OK);
   GNUNET_SERVER_client_drop (tcmc->client);
   GNUNET_free (tcmc);
@@ -5738,36 +5534,34 @@ handle_send (void *cls,
   size = ntohs (message->size);
   if (size <
       sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# payload received for other peers"),
-                            size,
-                            GNUNET_NO);
+                            gettext_noop ("# payload received for other peers"),
+                            size, GNUNET_NO);
   obm = (const struct OutboundMessage *) message;
   obmm = (const struct GNUNET_MessageHeader *) &obm[1];
   msize = size - sizeof (struct OutboundMessage);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' request from client with target `%4s' and message of type %u and size %u\n",
-              "SEND", GNUNET_i2s (&obm->peer),
-              ntohs (obmm->type),
-              msize);
+              "SEND", GNUNET_i2s (&obm->peer), ntohs (obmm->type), msize);
 #endif
   tcmc = GNUNET_malloc (sizeof (struct TransmitClientMessageContext) + msize);
   tcmc->client = client;
   tcmc->priority = ntohl (obm->priority);
-  tcmc->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh (obm->timeout));
+  tcmc->timeout =
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh
+                                        (obm->timeout));
   tcmc->msize = msize;
   /* FIXME: this memcpy can be up to 7% of our total runtime */
   memcpy (&tcmc[1], obmm, msize);
   GNUNET_SERVER_client_keep (client);
   setup_peer_check_blacklist (&obm->peer, GNUNET_YES,
-                              &transmit_client_message,
-                              tcmc);
+                              &transmit_client_message, tcmc);
 }
 
 
@@ -5784,19 +5578,18 @@ handle_request_connect (void *cls,
                         const struct GNUNET_MessageHeader *message)
 {
   const struct TransportRequestConnectMessage *trcm =
-    (const struct TransportRequestConnectMessage *) message;
+      (const struct TransportRequestConnectMessage *) message;
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# REQUEST CONNECT messages received"),
-                            1,
+                            gettext_noop
+                            ("# REQUEST CONNECT messages received"), 1,
                             GNUNET_NO);
 #if DEBUG_TRANSPORT
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 
-             "Received a request connect message for peer `%s'\n", 
-             GNUNET_i2s(&trcm->peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received a request connect message for peer `%s'\n",
+              GNUNET_i2s (&trcm->peer));
 #endif
-  setup_peer_check_blacklist (&trcm->peer, GNUNET_YES,
-                              NULL, NULL);
+  setup_peer_check_blacklist (&trcm->peer, GNUNET_YES, NULL, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -5813,47 +5606,43 @@ handle_set_quota (void *cls,
                   struct GNUNET_SERVER_Client *client,
                   const struct GNUNET_MessageHeader *message)
 {
-  const struct QuotaSetMessage *qsm =
-    (const struct QuotaSetMessage *) message;
+  const struct QuotaSetMessage *qsm = (const struct QuotaSetMessage *) message;
   struct NeighbourMapEntry *n;
 
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# SET QUOTA messages received"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# SET QUOTA messages received"),
+                            1, GNUNET_NO);
   n = find_neighbour (&qsm->peer);
   if (n == NULL)
-    {
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# SET QUOTA messages ignored (no such peer)"),
-                                1,
-                                GNUNET_NO);
-      return;
-    }
-#if DEBUG_TRANSPORT 
+  {
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# SET QUOTA messages ignored (no such peer)"),
+                              1, GNUNET_NO);
+    return;
+  }
+#if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' request (new quota %u, old quota %u) from client for peer `%4s'\n",
               "SET_QUOTA",
-              (unsigned int) ntohl (qsm->quota.value__),
-              (unsigned int) n->in_tracker.available_bytes_per_s__,
-              GNUNET_i2s (&qsm->peer));
+              (unsigned int) ntohl (qsm->quota.value__),
+              (unsigned int) n->in_tracker.available_bytes_per_s__,
+              GNUNET_i2s (&qsm->peer));
 #endif
-  GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker,
-                                         qsm->quota);
+  GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker, qsm->quota);
   if (0 == ntohl (qsm->quota.value__))
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&n->id),
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting peer `%4s', %s\n", GNUNET_i2s (&n->id),
                 "SET_QUOTA");
 #endif
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# disconnects due to quota of 0"),
-                                1,
-                                GNUNET_NO);
-      disconnect_neighbour (n, GNUNET_NO);
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# disconnects due to quota of 0"),
+                              1, GNUNET_NO);
+    disconnect_neighbour (n, GNUNET_NO);
+  }
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -5872,17 +5661,17 @@ transmit_address_to_client (void *cls, const char *address)
   size_t slen;
 
   if (NULL != address)
-    {
-      slen = strlen (address) + 1;
-      GNUNET_SERVER_transmit_context_append_data (tc, address, slen,
-                                                  GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
-    }
+  {
+    slen = strlen (address) + 1;
+    GNUNET_SERVER_transmit_context_append_data (tc, address, slen,
+                                                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+  }
   else
-    {
-      GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
-                                                  GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
-      GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
-    }
+  {
+    GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+                                                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+    GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
+  }
 }
 
 
@@ -5909,45 +5698,46 @@ handle_address_lookup (void *cls,
 
   size = ntohs (message->size);
   if (size < sizeof (struct AddressLookupMessage))
-    {
-      GNUNET_break_op (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   alum = (const struct AddressLookupMessage *) message;
   uint32_t addressLen = ntohl (alum->addrlen);
+
   if (size <= sizeof (struct AddressLookupMessage) + addressLen)
-    {
-      GNUNET_break_op (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   address = (const char *) &alum[1];
   nameTransport = (const char *) &address[addressLen];
   if (nameTransport
       [size - sizeof (struct AddressLookupMessage) - addressLen - 1] != '\0')
-    {
-      GNUNET_break_op (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   rtimeout = GNUNET_TIME_relative_ntoh (alum->timeout);
   numeric = ntohl (alum->numeric_only);
   lsPlugin = find_transport (nameTransport);
   if (NULL == lsPlugin)
-    {
-      tc = GNUNET_SERVER_transmit_context_create (client);
-      GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
-                                                  GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
-      GNUNET_SERVER_transmit_context_run (tc, rtimeout);
-      return;
-    }
+  {
+    tc = GNUNET_SERVER_transmit_context_create (client);
+    GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+                                                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+    GNUNET_SERVER_transmit_context_run (tc, rtimeout);
+    return;
+  }
   GNUNET_SERVER_disable_receive_done_warning (client);
   tc = GNUNET_SERVER_transmit_context_create (client);
   lsPlugin->api->address_pretty_printer (lsPlugin->api->cls,
-                                         nameTransport,
+                                         nameTransport,
                                          address, addressLen,
-                                         numeric,
+                                         numeric,
                                          rtimeout,
                                          &transmit_address_to_client, tc);
 }
@@ -5961,8 +5751,8 @@ handle_address_lookup (void *cls,
  */
 static void
 handle_peer_address_lookup (void *cls,
-                       struct GNUNET_SERVER_Client *client,
-                       const struct GNUNET_MessageHeader *message)
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message)
 {
   const struct PeerAddressLookupMessage *peer_address_lookup;
   struct NeighbourMapEntry *neighbor_iterator;
@@ -5977,11 +5767,11 @@ handle_peer_address_lookup (void *cls,
 
   size = ntohs (message->size);
   if (size < sizeof (struct PeerAddressLookupMessage))
-    {
-      GNUNET_break_op (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   peer_address_lookup = (const struct PeerAddressLookupMessage *) message;
 
   rtimeout = GNUNET_TIME_relative_ntoh (peer_address_lookup->timeout);
@@ -5990,56 +5780,54 @@ handle_peer_address_lookup (void *cls,
 
   /* Found no neighbor matching this peer id (shouldn't be possible, but...) */
   if (neighbor_iterator == NULL)
-    {
-      GNUNET_break(0);
-      tc = GNUNET_SERVER_transmit_context_create (client);
-      GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
-                                                  GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
-      GNUNET_SERVER_transmit_context_run (tc, rtimeout);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    tc = GNUNET_SERVER_transmit_context_create (client);
+    GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+                                                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+    GNUNET_SERVER_transmit_context_run (tc, rtimeout);
+    return;
+  }
 
   ready_iterator = neighbor_iterator->plugins;
   GNUNET_SERVER_disable_receive_done_warning (client);
   tc = GNUNET_SERVER_transmit_context_create (client);
-  while(ready_iterator != NULL)
+  while (ready_iterator != NULL)
+  {
+    foreign_address_iterator = ready_iterator->addresses;
+    while (foreign_address_iterator != NULL)
     {
-      foreign_address_iterator = ready_iterator->addresses;
-      while (foreign_address_iterator != NULL)
-        {
-          transport_plugin = foreign_address_iterator->ready_list->plugin;
-          if (foreign_address_iterator->addr != NULL)
-            {
-              GNUNET_asprintf (&addr_buf, "%s --- %s, %s",
-                               a2s (transport_plugin->short_name,
-                                    foreign_address_iterator->addr,
-                                    foreign_address_iterator->addrlen),
-                               (foreign_address_iterator->connected
-                                   == GNUNET_YES) ? "CONNECTED"
-                                   : "DISCONNECTED",
-                               (foreign_address_iterator->validated
-                                   == GNUNET_YES) ? "VALIDATED"
-                                   : "UNVALIDATED");
-              transmit_address_to_client(tc, addr_buf);
-              GNUNET_free (addr_buf);
-            }
-          else if (foreign_address_iterator->addrlen == 0)
-            {
-              GNUNET_asprintf (&addr_buf, "%s --- %s, %s", "<inbound>",
-                               (foreign_address_iterator->connected
-                                   == GNUNET_YES) ? "CONNECTED"
-                                   : "DISCONNECTED",
-                               (foreign_address_iterator->validated
-                                   == GNUNET_YES) ? "VALIDATED"
-                                   : "UNVALIDATED");
-              transmit_address_to_client (tc, addr_buf);
-              GNUNET_free (addr_buf);
-            }
-
-          foreign_address_iterator = foreign_address_iterator->next;
-        }
-      ready_iterator = ready_iterator->next;
+      transport_plugin = foreign_address_iterator->ready_list->plugin;
+      if (foreign_address_iterator->addr != NULL)
+      {
+        GNUNET_asprintf (&addr_buf, "%s --- %s, %s",
+                         a2s (transport_plugin->short_name,
+                              foreign_address_iterator->addr,
+                              foreign_address_iterator->addrlen),
+                         (foreign_address_iterator->connected
+                          == GNUNET_YES) ? "CONNECTED"
+                         : "DISCONNECTED",
+                         (foreign_address_iterator->validated
+                          == GNUNET_YES) ? "VALIDATED" : "UNVALIDATED");
+        transmit_address_to_client (tc, addr_buf);
+        GNUNET_free (addr_buf);
+      }
+      else if (foreign_address_iterator->addrlen == 0)
+      {
+        GNUNET_asprintf (&addr_buf, "%s --- %s, %s", "<inbound>",
+                         (foreign_address_iterator->connected
+                          == GNUNET_YES) ? "CONNECTED"
+                         : "DISCONNECTED",
+                         (foreign_address_iterator->validated
+                          == GNUNET_YES) ? "VALIDATED" : "UNVALIDATED");
+        transmit_address_to_client (tc, addr_buf);
+        GNUNET_free (addr_buf);
+      }
+
+      foreign_address_iterator = foreign_address_iterator->next;
     }
+    ready_iterator = ready_iterator->next;
+  }
   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
   GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
@@ -6048,9 +5836,7 @@ handle_peer_address_lookup (void *cls,
 
 
 static int
-output_addresses (void *cls,
-                  const GNUNET_HashCode *key,
-                  void *value)
+output_addresses (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_SERVER_TransmitContext *tc = cls;
   struct NeighbourMapEntry *neighbor_iterator = value;
@@ -6061,46 +5847,44 @@ output_addresses (void *cls,
 
   ready_iterator = neighbor_iterator->plugins;
   while (ready_iterator != NULL)
+  {
+    foreign_address_iterator = ready_iterator->addresses;
+    while (foreign_address_iterator != NULL)
     {
-      foreign_address_iterator = ready_iterator->addresses;
-      while (foreign_address_iterator != NULL)
-        {
-          transport_plugin = foreign_address_iterator->ready_list->plugin;
-          if (foreign_address_iterator->addr != NULL)
-            {
-              GNUNET_asprintf (&addr_buf, "%s:%s --- %s, %s",
-                               GNUNET_i2s(&neighbor_iterator->id),
-                               a2s (transport_plugin->short_name,
-                                    foreign_address_iterator->addr,
-                                    foreign_address_iterator->addrlen),
-                               (foreign_address_iterator->connected
-                                == GNUNET_YES) ? "CONNECTED"
-                               : "DISCONNECTED",
-                               (foreign_address_iterator->validated
-                                == GNUNET_YES) ? "VALIDATED"
-                               : "UNVALIDATED");
-              transmit_address_to_client (tc, addr_buf);
-              GNUNET_free (addr_buf);
-            }
-          else if (foreign_address_iterator->addrlen == 0)
-            {
-              GNUNET_asprintf (&addr_buf, "%s:%s --- %s, %s",
-                               GNUNET_i2s (&neighbor_iterator->id),
-                               "<inbound>",
-                               (foreign_address_iterator->connected
-                                == GNUNET_YES) ? "CONNECTED"
-                               : "DISCONNECTED",
-                               (foreign_address_iterator->validated
-                                == GNUNET_YES) ? "VALIDATED"
-                               : "UNVALIDATED");
-              transmit_address_to_client (tc, addr_buf);
-              GNUNET_free (addr_buf);
-            }
-          
-          foreign_address_iterator = foreign_address_iterator->next;
-        }
-      ready_iterator = ready_iterator->next;
+      transport_plugin = foreign_address_iterator->ready_list->plugin;
+      if (foreign_address_iterator->addr != NULL)
+      {
+        GNUNET_asprintf (&addr_buf, "%s:%s --- %s, %s",
+                         GNUNET_i2s (&neighbor_iterator->id),
+                         a2s (transport_plugin->short_name,
+                              foreign_address_iterator->addr,
+                              foreign_address_iterator->addrlen),
+                         (foreign_address_iterator->connected
+                          == GNUNET_YES) ? "CONNECTED"
+                         : "DISCONNECTED",
+                         (foreign_address_iterator->validated
+                          == GNUNET_YES) ? "VALIDATED" : "UNVALIDATED");
+        transmit_address_to_client (tc, addr_buf);
+        GNUNET_free (addr_buf);
+      }
+      else if (foreign_address_iterator->addrlen == 0)
+      {
+        GNUNET_asprintf (&addr_buf, "%s:%s --- %s, %s",
+                         GNUNET_i2s (&neighbor_iterator->id),
+                         "<inbound>",
+                         (foreign_address_iterator->connected
+                          == GNUNET_YES) ? "CONNECTED"
+                         : "DISCONNECTED",
+                         (foreign_address_iterator->validated
+                          == GNUNET_YES) ? "VALIDATED" : "UNVALIDATED");
+        transmit_address_to_client (tc, addr_buf);
+        GNUNET_free (addr_buf);
+      }
+
+      foreign_address_iterator = foreign_address_iterator->next;
     }
+    ready_iterator = ready_iterator->next;
+  }
   return GNUNET_OK;
 }
 
@@ -6122,16 +5906,14 @@ handle_address_iterate (void *cls,
 
   size = ntohs (message->size);
   if (size < sizeof (struct AddressIterateMessage))
-    {
-      GNUNET_break_op (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   GNUNET_SERVER_disable_receive_done_warning (client);
   tc = GNUNET_SERVER_transmit_context_create (client);
-  GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &output_addresses,
-                                         tc);
+  GNUNET_CONTAINER_multihashmap_iterate (neighbours, &output_addresses, tc);
   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
   GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
@@ -6141,7 +5923,7 @@ handle_address_iterate (void *cls,
 static const struct GNUNET_MessageHeader *
 do_get_our_hello ()
 {
-  return (const struct GNUNET_MessageHeader*) our_hello;
+  return (const struct GNUNET_MessageHeader *) our_hello;
 }
 
 
@@ -6167,8 +5949,7 @@ create_environment (struct TransportPlugin *plug)
  * Start the specified transport (load the plugin).
  */
 static void
-start_transport (struct GNUNET_SERVER_Handle *server,
-                 const char *name)
+start_transport (struct GNUNET_SERVER_Handle *server, const char *name)
 {
   struct TransportPlugin *plug;
   char *libname;
@@ -6184,31 +5965,29 @@ start_transport (struct GNUNET_SERVER_Handle *server,
   plugins = plug;
   plug->api = GNUNET_PLUGIN_load (libname, &plug->env);
   if (plug->api == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to load transport plugin for `%s'\n"), name);
-      GNUNET_free (plug->short_name);
-      plugins = plug->next;
-      GNUNET_free (libname);
-      GNUNET_free (plug);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to load transport plugin for `%s'\n"), name);
+    GNUNET_free (plug->short_name);
+    plugins = plug->next;
+    GNUNET_free (libname);
+    GNUNET_free (plug);
+  }
 }
 
 
 static int
-null_mq_client_pointers (void *cls,
-                         const GNUNET_HashCode *key,
-                         void *value)
+null_mq_client_pointers (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct TransportClient *pos = cls;
   struct NeighbourMapEntry *n = value;
   struct MessageQueue *mq;
 
   for (mq = n->messages_head; mq != NULL; mq = mq->next)
-    {
-      if (mq->client == pos)
-        mq->client = NULL; /* do not use anymore! */
-    }
+  {
+    if (mq->client == pos)
+      mq->client = NULL;        /* do not use anymore! */
+  }
   return GNUNET_OK;
 }
 
@@ -6221,8 +6000,7 @@ null_mq_client_pointers (void *cls,
  * @param client identification of the client
  */
 static void
-client_disconnect_notification (void *cls,
-                                struct GNUNET_SERVER_Client *client)
+client_disconnect_notification (void *cls, struct GNUNET_SERVER_Client *client)
 {
   struct TransportClient *pos;
   struct TransportClient *prev;
@@ -6239,89 +6017,81 @@ client_disconnect_notification (void *cls,
   /* clean up blacklister */
   bl = bl_head;
   while (bl != NULL)
+  {
+    if (bl->client == client)
     {
-      if (bl->client == client)
-        {
-          bc = bc_head;
-          while (bc != NULL)
-            {
-              if (bc->bl_pos == bl)
-                {
-                  bc->bl_pos = bl->next;
-                  if (bc->th != NULL)
-                    {
-                      GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
-                      bc->th = NULL;
-                    }
-                  if (bc->task == GNUNET_SCHEDULER_NO_TASK)
-                    bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                                         bc);
-                  break;
-                }
-              bc = bc->next;
-            }
-          GNUNET_CONTAINER_DLL_remove (bl_head,
-                                       bl_tail,
-                                       bl);
-          GNUNET_SERVER_client_drop (bl->client);
-          GNUNET_free (bl);
-          break;
-        }
-      bl = bl->next;
+      bc = bc_head;
+      while (bc != NULL)
+      {
+        if (bc->bl_pos == bl)
+        {
+          bc->bl_pos = bl->next;
+          if (bc->th != NULL)
+          {
+            GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
+            bc->th = NULL;
+          }
+          if (bc->task == GNUNET_SCHEDULER_NO_TASK)
+            bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+          break;
+        }
+        bc = bc->next;
+      }
+      GNUNET_CONTAINER_DLL_remove (bl_head, bl_tail, bl);
+      GNUNET_SERVER_client_drop (bl->client);
+      GNUNET_free (bl);
+      break;
     }
+    bl = bl->next;
+  }
   /* clean up 'normal' clients */
   prev = NULL;
   pos = clients;
   while ((pos != NULL) && (pos->client != client))
-    {
-      prev = pos;
-      pos = pos->next;
-    }
+  {
+    prev = pos;
+    pos = pos->next;
+  }
   if (pos == NULL)
     return;
   while (NULL != (mqe = pos->message_queue_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (pos->message_queue_head,
-                                   pos->message_queue_tail,
-                                   mqe);
-      pos->message_count--;
-      GNUNET_free (mqe);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (pos->message_queue_head,
+                                 pos->message_queue_tail, mqe);
+    pos->message_count--;
+    GNUNET_free (mqe);
+  }
   if (NULL != neighbours)
     GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                           &null_mq_client_pointers,
-                                           pos);
+                                           &null_mq_client_pointers, pos);
   if (prev == NULL)
     clients = pos->next;
   else
     prev->next = pos->next;
   if (GNUNET_YES == pos->tcs_pending)
-    {
-      pos->client = NULL;
-      return;
-    }
+  {
+    pos->client = NULL;
+    return;
+  }
   if (pos->th != NULL)
-    {
-      GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
-      pos->th = NULL;
-    }
+  {
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
+    pos->th = NULL;
+  }
   GNUNET_break (0 == pos->message_count);
   GNUNET_free (pos);
 }
 
 
 static int
-disconnect_all_neighbours (void *cls,
-                           const GNUNET_HashCode *key,
-                           void *value)
+disconnect_all_neighbours (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct NeighbourMapEntry *n = value;
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting peer `%4s', %s\n",
-              GNUNET_i2s(&n->id),
-              "SHUTDOWN_TASK");
+              "Disconnecting peer `%4s', %s\n",
+              GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
 #endif
   disconnect_neighbour (n, GNUNET_NO);
   return GNUNET_OK;
@@ -6344,44 +6114,42 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   shutdown_in_progress = GNUNET_YES;
   GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &disconnect_all_neighbours,
-                                         NULL);
+                                         &disconnect_all_neighbours, NULL);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Transport service is unloading plugins...\n");
 #endif
   while (NULL != (plug = plugins))
+  {
+    if (plug->address_update_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      if (plug->address_update_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (plug->address_update_task);
-          plug->address_update_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
-      GNUNET_free (plug->lib_name);
-      GNUNET_free (plug->short_name);
-      while (NULL != (al = plug->addresses))
-        {
-          plug->addresses = al->next;
-          GNUNET_free (al);
-        }
-      plugins = plug->next;
-      GNUNET_free (plug);
+      GNUNET_SCHEDULER_cancel (plug->address_update_task);
+      plug->address_update_task = GNUNET_SCHEDULER_NO_TASK;
     }
+    GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
+    GNUNET_free (plug->lib_name);
+    GNUNET_free (plug->short_name);
+    while (NULL != (al = plug->addresses))
+    {
+      plug->addresses = al->next;
+      GNUNET_free (al);
+    }
+    plugins = plug->next;
+    GNUNET_free (plug);
+  }
   if (my_private_key != NULL)
     GNUNET_CRYPTO_rsa_key_free (my_private_key);
   GNUNET_free_non_null (our_hello);
 
   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
-                                         &abort_validation,
-                                         NULL);
+                                         &abort_validation, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (validation_map);
   validation_map = NULL;
 
 
   if (ats_task != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(ats_task);
+    GNUNET_SCHEDULER_cancel (ats_task);
     ats_task = GNUNET_SCHEDULER_NO_TASK;
   }
 #if HAVE_LIBGLPK
@@ -6391,41 +6159,41 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   /* free 'chvc' data structure */
   while (NULL != (chvc = chvc_head))
+  {
+    chvc_head = chvc->next;
+    if (chvc->piter != NULL)
     {
-      chvc_head = chvc->next;
-      if (chvc->piter != NULL)
-        {
-          GNUNET_PEERINFO_iterate_cancel (chvc->piter);
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# outstanding peerinfo iterate requests"),
-                                    -1,
-                                    GNUNET_NO);
-          chvc->ve_count --;
-        }
-      else
-          GNUNET_break (0);
-      GNUNET_assert (chvc->ve_count == 0);
-      GNUNET_free (chvc);
+      GNUNET_PEERINFO_iterate_cancel (chvc->piter);
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# outstanding peerinfo iterate requests"), -1,
+                                GNUNET_NO);
+      chvc->ve_count--;
     }
+    else
+      GNUNET_break (0);
+    GNUNET_assert (chvc->ve_count == 0);
+    GNUNET_free (chvc);
+  }
   chvc_tail = NULL;
 
   if (stats != NULL)
-    {
-      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }
   if (peerinfo != NULL)
-    {
-      GNUNET_PEERINFO_disconnect (peerinfo);
-      peerinfo = NULL;
-    }
+  {
+    GNUNET_PEERINFO_disconnect (peerinfo);
+    peerinfo = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != hello_task)
-    {
-      GNUNET_SCHEDULER_cancel (hello_task);
-      hello_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (hello_task);
+    hello_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   /* Can we assume those are gone by now, or do we need to clean up
-     explicitly!? */
+   * explicitly!? */
   GNUNET_break (bl_head == NULL);
   GNUNET_break (bc_head == NULL);
   GNUNET_CONTAINER_multihashmap_destroy (neighbours);
@@ -6433,17 +6201,17 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 }
 
 
-void ats_result_cb ()
+void
+ats_result_cb ()
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-      "ATS Result callback\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS Result callback\n");
 }
 
 
 #if HAVE_LIBGLPK
 struct AtsBuildContext
 {
-  struct ATS_mechanism * mechanisms;
+  struct ATS_mechanism *mechanisms;
   struct ATS_peer *peers;
   int c_peers;
   int c_mechs;
@@ -6451,70 +6219,70 @@ struct AtsBuildContext
 
 
 static int
-find_and_count_addresses (void *cls,
-                          const GNUNET_HashCode *key,
-                          void *value)
+find_and_count_addresses (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct AtsBuildContext *abc = cls;
-  struct NeighbourMapEntry *next = value;  
+  struct NeighbourMapEntry *next = value;
   int found_addresses = GNUNET_NO;
-  
+
   struct ReadyList *r_next = next->plugins;
+
   while (r_next != NULL)
+  {
+    struct ForeignAddressList *a_next = r_next->addresses;
+
+    while (a_next != NULL)
     {
-      struct ForeignAddressList * a_next = r_next->addresses;
-      while (a_next != NULL)
-        {
-          abc->c_mechs++;
-          found_addresses = GNUNET_YES;
-          a_next = a_next->next;
-        }
-      r_next = r_next->next;
+      abc->c_mechs++;
+      found_addresses = GNUNET_YES;
+      a_next = a_next->next;
     }
-  if (found_addresses) 
+    r_next = r_next->next;
+  }
+  if (found_addresses)
     abc->c_peers++;
   return GNUNET_OK;
 }
 
 
 static int
-setup_ats_problem (void *cls,
-                   const GNUNET_HashCode *key,
-                   void *value)
+setup_ats_problem (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct AtsBuildContext *abc = cls;
-  struct NeighbourMapEntry *next = value;  
+  struct NeighbourMapEntry *next = value;
 
   int found_addresses = GNUNET_NO;
   struct ReadyList *r_next = next->plugins;
+
   while (r_next != NULL)
+  {
+    struct ForeignAddressList *a_next = r_next->addresses;
+
+    while (a_next != NULL)
     {
-      struct ForeignAddressList * a_next = r_next->addresses;
-      while (a_next != NULL)
-        {
-          if (found_addresses == GNUNET_NO)
-            {
-              abc->peers[abc->c_peers].peer = next->id;
-              abc->peers[abc->c_peers].m_head = NULL;
-              abc->peers[abc->c_peers].m_tail = NULL;
-              abc->peers[abc->c_peers].f = 1.0 / abc->c_mechs;
-            }
-          abc->mechanisms[abc->c_mechs].addr = a_next;
-          abc->mechanisms[abc->c_mechs].col_index = abc->c_mechs;
-          abc->mechanisms[abc->c_mechs].peer = &abc->peers[abc->c_peers];
-          abc->mechanisms[abc->c_mechs].next = NULL;
-          abc->mechanisms[abc->c_mechs].plugin = r_next->plugin;
-          abc->mechanisms[abc->c_mechs].ressources = a_next->ressources;
-          abc->mechanisms[abc->c_mechs].quality = a_next->quality;
-          GNUNET_CONTAINER_DLL_insert_tail(abc->peers[abc->c_peers].m_head,
-                                           abc->peers[abc->c_peers].m_tail,
-                                           &abc->mechanisms[abc->c_mechs]);
-          found_addresses = GNUNET_YES;
-          abc->c_mechs++;             
-          a_next = a_next->next;
-        }
-      r_next = r_next->next;
-    }
+      if (found_addresses == GNUNET_NO)
+      {
+        abc->peers[abc->c_peers].peer = next->id;
+        abc->peers[abc->c_peers].m_head = NULL;
+        abc->peers[abc->c_peers].m_tail = NULL;
+        abc->peers[abc->c_peers].f = 1.0 / abc->c_mechs;
+      }
+      abc->mechanisms[abc->c_mechs].addr = a_next;
+      abc->mechanisms[abc->c_mechs].col_index = abc->c_mechs;
+      abc->mechanisms[abc->c_mechs].peer = &abc->peers[abc->c_peers];
+      abc->mechanisms[abc->c_mechs].next = NULL;
+      abc->mechanisms[abc->c_mechs].plugin = r_next->plugin;
+      abc->mechanisms[abc->c_mechs].ressources = a_next->ressources;
+      abc->mechanisms[abc->c_mechs].quality = a_next->quality;
+      GNUNET_CONTAINER_DLL_insert_tail (abc->peers[abc->c_peers].m_head,
+                                        abc->peers[abc->c_peers].m_tail,
+                                        &abc->mechanisms[abc->c_mechs]);
+      found_addresses = GNUNET_YES;
+      abc->c_mechs++;
+      a_next = a_next->next;
+    }
+    r_next = r_next->next;
+  }
   if (found_addresses == GNUNET_YES)
     abc->c_peers++;
   return GNUNET_OK;
@@ -6522,43 +6290,40 @@ setup_ats_problem (void *cls,
 
 
 static void
-create_ats_information ( struct ATS_peer **p,
-                         int * c_p,
-                         struct ATS_mechanism ** m,
-                         int * c_m )
+create_ats_information (struct ATS_peer **p,
+                        int *c_p, struct ATS_mechanism **m, int *c_m)
 {
   struct AtsBuildContext abc;
 
 #if VERBOSE_ATS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-      "ATS requires clean address information\n");
+              "ATS requires clean address information\n");
 #endif
   abc.c_peers = 0;
   abc.c_mechs = 0;
   GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &find_and_count_addresses,
-                                         &abc);
+                                         &find_and_count_addresses, &abc);
 #if VERBOSE_ATS
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-      "Found %u peers with % u transport mechanisms\n", c_peers, c_mechs);
+              "Found %u peers with % u transport mechanisms\n", c_peers,
+              c_mechs);
 #endif
 
-  if ( (abc.c_peers == 0) && (abc.c_mechs == 0) )
-    {
-      *p = NULL;
-      (*c_p) = 0;
-      *m = NULL;
-      (*c_m) = 0;
-      return;
-    }
+  if ((abc.c_peers == 0) && (abc.c_mechs == 0))
+  {
+    *p = NULL;
+    (*c_p) = 0;
+    *m = NULL;
+    (*c_m) = 0;
+    return;
+  }
 
-  abc.mechanisms = GNUNET_malloc((1+abc.c_mechs) * sizeof (struct ATS_mechanism));
-  abc.peers =  GNUNET_malloc((1+abc.c_peers) * sizeof (struct ATS_peer));
+  abc.mechanisms =
+      GNUNET_malloc ((1 + abc.c_mechs) * sizeof (struct ATS_mechanism));
+  abc.peers = GNUNET_malloc ((1 + abc.c_peers) * sizeof (struct ATS_peer));
   abc.c_mechs = 1;
   abc.c_peers = 1;
-  GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &setup_ats_problem,
-                                         &abc);
+  GNUNET_CONTAINER_multihashmap_iterate (neighbours, &setup_ats_problem, &abc);
   abc.c_mechs--;
   abc.c_peers--;
   (*c_m) = abc.c_mechs;
@@ -6569,27 +6334,29 @@ create_ats_information ( struct ATS_peer **p,
 
 
 static void
-schedule_ats (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+schedule_ats (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ATS_Handle *ats = (struct ATS_Handle *) cls;
-  if (ats==NULL)
+
+  if (ats == NULL)
     return;
 
   ats_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-      return;
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
 
   if (shutdown_in_progress == GNUNET_YES)
-          return;
+    return;
 
   struct GNUNET_TIME_Relative delta =
-      GNUNET_TIME_absolute_get_difference (last_ats_execution, GNUNET_TIME_absolute_get());
+      GNUNET_TIME_absolute_get_difference (last_ats_execution,
+                                           GNUNET_TIME_absolute_get ());
+
   if (delta.rel_value < ats_minimum_interval.rel_value)
   {
 #if DEBUG_ATS
     GNUNET_log (GNUNET_ERROR_TYPE_BULK,
-        "Minimum time between cycles not reached\n");
+                "Minimum time between cycles not reached\n");
 #endif
     return;
   }
@@ -6600,19 +6367,19 @@ schedule_ats (void *cls,
 #if HAVE_LIBGLPK
   ats_calculate_bandwidth_distribution (ats);
 #endif
-  last_ats_execution = GNUNET_TIME_absolute_get();
+  last_ats_execution = GNUNET_TIME_absolute_get ();
 
   ats_task = GNUNET_SCHEDULER_add_delayed (ats_regular_interval,
-                                  &schedule_ats, ats);
+                                           &schedule_ats, ats);
 }
 #endif
 
 
-struct ForeignAddressList * get_preferred_ats_address (
-                struct NeighbourMapEntry *n)
+struct ForeignAddressList *
+get_preferred_ats_address (struct NeighbourMapEntry *n)
 {
   // TODO get ATS prefered address
-  return find_ready_address(n);
+  return find_ready_address (n);
 }
 
 /**
@@ -6635,7 +6402,8 @@ run (void *cls,
     {&handle_send, NULL,
      GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, 0},
     {&handle_request_connect, NULL,
-     GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT, sizeof(struct TransportRequestConnectMessage)},
+     GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT,
+     sizeof (struct TransportRequestConnectMessage)},
     {&handle_set_quota, NULL,
      GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)},
     {&handle_address_lookup, NULL,
@@ -6648,9 +6416,11 @@ run (void *cls,
      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE,
      0},
     {&handle_blacklist_init, NULL,
-     GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, sizeof (struct GNUNET_MessageHeader)},
+     GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT,
+     sizeof (struct GNUNET_MessageHeader)},
     {&handle_blacklist_reply, NULL,
-     GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, sizeof (struct BlacklistMessage)},
+     GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY,
+     sizeof (struct BlacklistMessage)},
     {NULL, NULL, 0, 0}
   };
   char *plugs;
@@ -6674,61 +6444,60 @@ run (void *cls,
        GNUNET_CONFIGURATION_get_value_filename (c,
                                                 "GNUNETD",
                                                 "HOSTKEY", &keyfile)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Transport service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    if (stats != NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      if (stats != NULL)
-        {
-          GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-          stats = NULL;
-        }
-      GNUNET_CONTAINER_multihashmap_destroy (validation_map);
-      validation_map = NULL;
-      GNUNET_CONTAINER_multihashmap_destroy (neighbours);
-      neighbours = NULL;
-      return;
+      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+      stats = NULL;
     }
+    GNUNET_CONTAINER_multihashmap_destroy (validation_map);
+    validation_map = NULL;
+    GNUNET_CONTAINER_multihashmap_destroy (neighbours);
+    neighbours = NULL;
+    return;
+  }
 
   max_connect_per_transport = (uint32_t) tneigh;
   peerinfo = GNUNET_PEERINFO_connect (cfg);
   if (peerinfo == NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not access PEERINFO service.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    if (stats != NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not access PEERINFO service.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      if (stats != NULL)
-        {
-          GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-          stats = NULL;
-        }
-      GNUNET_CONTAINER_multihashmap_destroy (validation_map);
-      validation_map = NULL;
-      GNUNET_CONTAINER_multihashmap_destroy (neighbours);
-      neighbours = NULL;
-      GNUNET_free (keyfile);
-      return;
+      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+      stats = NULL;
     }
+    GNUNET_CONTAINER_multihashmap_destroy (validation_map);
+    validation_map = NULL;
+    GNUNET_CONTAINER_multihashmap_destroy (neighbours);
+    neighbours = NULL;
+    GNUNET_free (keyfile);
+    return;
+  }
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (my_private_key == NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    if (stats != NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service could not access hostkey.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      if (stats != NULL)
-        {
-          GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-          stats = NULL;
-        }
-      GNUNET_CONTAINER_multihashmap_destroy (validation_map);
-      validation_map = NULL;
-      GNUNET_CONTAINER_multihashmap_destroy (neighbours);
-      neighbours = NULL;
-      return;
+      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+      stats = NULL;
     }
+    GNUNET_CONTAINER_multihashmap_destroy (validation_map);
+    validation_map = NULL;
+    GNUNET_CONTAINER_multihashmap_destroy (neighbours);
+    neighbours = NULL;
+    return;
+  }
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
   GNUNET_CRYPTO_hash (&my_public_key,
                       sizeof (my_public_key), &my_identity.hashPubKey);
@@ -6738,20 +6507,19 @@ run (void *cls,
   /* load plugins... */
   no_transports = 1;
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_string (c,
-                                             "TRANSPORT", "PLUGINS", &plugs))
+      GNUNET_CONFIGURATION_get_value_string (c, "TRANSPORT", "PLUGINS", &plugs))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("Starting transport plugins `%s'\n"), plugs);
+    pos = strtok (plugs, " ");
+    while (pos != NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Starting transport plugins `%s'\n"), plugs);
-      pos = strtok (plugs, " ");
-      while (pos != NULL)
-        {
-          start_transport (server, pos);
-          no_transports = 0;
-          pos = strtok (NULL, " ");
-        }
-      GNUNET_free (plugs);
+      start_transport (server, pos);
+      no_transports = 0;
+      pos = strtok (NULL, " ");
     }
+    GNUNET_free (plugs);
+  }
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &shutdown_task, NULL);
   if (no_transports)
@@ -6759,8 +6527,9 @@ run (void *cls,
 
   /* Initializing ATS */
   int co;
-  char * section;
-  unsigned long long  value;
+  char *section;
+  unsigned long long value;
+
 #if HAVE_LIBGLPK
   double D = 1.0;
   double U = 1.0;
@@ -6773,39 +6542,35 @@ run (void *cls,
   ats_regular_interval = ATS_EXEC_INTERVAL;
 
   /* loading cost ressources */
-  for (co=0; co<available_ressources; co++)
+  for (co = 0; co < available_ressources; co++)
   {
-    GNUNET_asprintf(&section,"%s_UP",ressources[co].cfg_param);
-    if (GNUNET_CONFIGURATION_have_value(cfg, "transport", section))
+    GNUNET_asprintf (&section, "%s_UP", ressources[co].cfg_param);
+    if (GNUNET_CONFIGURATION_have_value (cfg, "transport", section))
     {
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg,
-          "transport",
-          section,
-          &value))
+      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              "transport",
+                                                              section, &value))
       {
 #if DEBUG_ATS
-              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Found ressource cost: [%s] = %llu\n",
-                  section, value);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Found ressource cost: [%s] = %llu\n", section, value);
 #endif
-              ressources[co].c_max = value;
+        ressources[co].c_max = value;
       }
     }
     GNUNET_free (section);
-    GNUNET_asprintf(&section,"%s_DOWN",ressources[co].cfg_param);
-    if (GNUNET_CONFIGURATION_have_value(cfg, "transport", section))
+    GNUNET_asprintf (&section, "%s_DOWN", ressources[co].cfg_param);
+    if (GNUNET_CONFIGURATION_have_value (cfg, "transport", section))
     {
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg,
-          "transport",
-          section,
-          &value))
+      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              "transport",
+                                                              section, &value))
       {
 #if DEBUG_ATS
-              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Found ressource cost: [%s] = %llu\n",
-                  section, value);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Found ressource cost: [%s] = %llu\n", section, value);
 #endif
-              ressources[co].c_min = value;
+        ressources[co].c_min = value;
       }
     }
     GNUNET_free (section);
@@ -6813,32 +6578,28 @@ run (void *cls,
 #if HAVE_LIBGLPK
   ats = ats_init (D, U, R, v_b_min, v_n_min,
                   ATS_MAX_ITERATIONS, ATS_MAX_EXEC_DURATION,
-                  &create_ats_information,
-                  ats_result_cb);
-  ats_set_logging_options (ats,
-                           stats,
-                           cfg);
+                  &create_ats_information, ats_result_cb);
+  ats_set_logging_options (ats, stats, cfg);
   GNUNET_break (GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_time (cfg,
-                                                     "transport",
-                                                     "ATS_EXEC_INTERVAL", 
-                                                     &ats_regular_interval));
+                GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                     "transport",
+                                                     "ATS_EXEC_INTERVAL",
+                                                     &ats_regular_interval));
   GNUNET_break (GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_time (cfg,
-                                                     "transport",
-                                                     "ATS_MIN_INTERVAL", 
-                                                     &ats_minimum_interval));
+                GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                     "transport",
+                                                     "ATS_MIN_INTERVAL",
+                                                     &ats_minimum_interval));
   if (ats != NULL)
     ats_task = GNUNET_SCHEDULER_add_now (&schedule_ats, ats);
 #endif
 
 
 #if DEBUG_TRANSPORT
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-              _("Transport service ready.\n"));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport service ready.\n"));
 #endif
   /* If we have a blacklist file, read from it */
-  read_blacklist_file(cfg);
+  read_blacklist_file (cfg);
   /* process client requests */
   GNUNET_SERVER_add_handlers (server, handlers);
 }
@@ -6854,13 +6615,12 @@ run (void *cls,
 int
 main (int argc, char *const *argv)
 {
-  a2s (NULL, NULL, 0); /* make compiler happy */
+  a2s (NULL, NULL, 0);          /* make compiler happy */
   return (GNUNET_OK ==
           GNUNET_SERVICE_run (argc,
                               argv,
                               "transport",
-                              GNUNET_SERVICE_OPTION_NONE,
-                              &run, NULL)) ? 0 : 1;
+                              GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
 }
 
 /* end of gnunet-service-transport.c */
diff --git a/src/transport/gnunet-service-transport_ats.c b/src/transport/gnunet-service-transport_ats.c
index df425bfb0..34d1791b9 100644
--- a/src/transport/gnunet-service-transport_ats.c
+++ b/src/transport/gnunet-service-transport_ats.c
@@ -41,133 +41,136 @@
 
 #ifndef GLP_PROB_DEFINED
 #define GLP_PROB_DEFINED
-  typedef struct { double _opaque_prob[100]; } glp_prob;
+typedef struct
+{
+  double _opaque_prob[100];
+} glp_prob;
 #endif
 
 typedef struct
-{     /* integer optimizer control parameters */
-    int msg_lev;            /* message level (see glp_smcp) */
-    int br_tech;            /* branching technique: */
-#define GLP_BR_FFV         1  /* first fractional variable */
-#define GLP_BR_LFV         2  /* last fractional variable */
-#define GLP_BR_MFV         3  /* most fractional variable */
-#define GLP_BR_DTH         4  /* heuristic by Driebeck and Tomlin */
-#define GLP_BR_PCH         5  /* hybrid pseudocost heuristic */
-    int bt_tech;            /* backtracking technique: */
-#define GLP_BT_DFS         1  /* depth first search */
-#define GLP_BT_BFS         2  /* breadth first search */
-#define GLP_BT_BLB         3  /* best local bound */
-#define GLP_BT_BPH         4  /* best projection heuristic */
-    double tol_int;         /* mip.tol_int */
-    double tol_obj;         /* mip.tol_obj */
-    int tm_lim;             /* mip.tm_lim (milliseconds) */
-    int out_frq;            /* mip.out_frq (milliseconds) */
-    int out_dly;            /* mip.out_dly (milliseconds) */
-                            /* mip.cb_func */
-    void *cb_info;          /* mip.cb_info */
-    int cb_size;            /* mip.cb_size */
-    int pp_tech;            /* preprocessing technique: */
-#define GLP_PP_NONE        0  /* disable preprocessing */
-#define GLP_PP_ROOT        1  /* preprocessing only on root level */
-#define GLP_PP_ALL         2  /* preprocessing on all levels */
-    double mip_gap;         /* relative MIP gap tolerance */
-    int mir_cuts;           /* MIR cuts       (GLP_ON/GLP_OFF) */
-    int gmi_cuts;           /* Gomory's cuts  (GLP_ON/GLP_OFF) */
-    int cov_cuts;           /* cover cuts     (GLP_ON/GLP_OFF) */
-    int clq_cuts;           /* clique cuts    (GLP_ON/GLP_OFF) */
-    int presolve;           /* enable/disable using MIP presolver */
-    int binarize;           /* try to binarize integer variables */
-    int fp_heur;            /* feasibility pump heuristic */
-#if 1 /* 28/V-2010 */
-    int alien;              /* use alien solver */
-#endif
-    double foo_bar[29];     /* (reserved) */
+{                               /* integer optimizer control parameters */
+  int msg_lev;                  /* message level (see glp_smcp) */
+  int br_tech;                  /* branching technique: */
+#define GLP_BR_FFV         1    /* first fractional variable */
+#define GLP_BR_LFV         2    /* last fractional variable */
+#define GLP_BR_MFV         3    /* most fractional variable */
+#define GLP_BR_DTH         4    /* heuristic by Driebeck and Tomlin */
+#define GLP_BR_PCH         5    /* hybrid pseudocost heuristic */
+  int bt_tech;                  /* backtracking technique: */
+#define GLP_BT_DFS         1    /* depth first search */
+#define GLP_BT_BFS         2    /* breadth first search */
+#define GLP_BT_BLB         3    /* best local bound */
+#define GLP_BT_BPH         4    /* best projection heuristic */
+  double tol_int;               /* mip.tol_int */
+  double tol_obj;               /* mip.tol_obj */
+  int tm_lim;                   /* mip.tm_lim (milliseconds) */
+  int out_frq;                  /* mip.out_frq (milliseconds) */
+  int out_dly;                  /* mip.out_dly (milliseconds) */
+  /* mip.cb_func */
+  void *cb_info;                /* mip.cb_info */
+  int cb_size;                  /* mip.cb_size */
+  int pp_tech;                  /* preprocessing technique: */
+#define GLP_PP_NONE        0    /* disable preprocessing */
+#define GLP_PP_ROOT        1    /* preprocessing only on root level */
+#define GLP_PP_ALL         2    /* preprocessing on all levels */
+  double mip_gap;               /* relative MIP gap tolerance */
+  int mir_cuts;                 /* MIR cuts       (GLP_ON/GLP_OFF) */
+  int gmi_cuts;                 /* Gomory's cuts  (GLP_ON/GLP_OFF) */
+  int cov_cuts;                 /* cover cuts     (GLP_ON/GLP_OFF) */
+  int clq_cuts;                 /* clique cuts    (GLP_ON/GLP_OFF) */
+  int presolve;                 /* enable/disable using MIP presolver */
+  int binarize;                 /* try to binarize integer variables */
+  int fp_heur;                  /* feasibility pump heuristic */
+#if 1                           /* 28/V-2010 */
+  int alien;                    /* use alien solver */
+#endif
+  double foo_bar[29];           /* (reserved) */
 } glp_iocp;
 
 typedef struct
-{     /* simplex method control parameters */
-      int msg_lev;            /* message level: */
-#define GLP_MSG_OFF        0  /* no output */
-#define GLP_MSG_ERR        1  /* warning and error messages only */
-#define GLP_MSG_ON         2  /* normal output */
-#define GLP_MSG_ALL        3  /* full output */
-#define GLP_MSG_DBG        4  /* debug output */
-      int meth;               /* simplex method option: */
-#define GLP_PRIMAL         1  /* use primal simplex */
-#define GLP_DUALP          2  /* use dual; if it fails, use primal */
-#define GLP_DUAL           3  /* use dual simplex */
-      int pricing;            /* pricing technique: */
-#define GLP_PT_STD      0x11  /* standard (Dantzig rule) */
-#define GLP_PT_PSE      0x22  /* projected steepest edge */
-      int r_test;             /* ratio test technique: */
-#define GLP_RT_STD      0x11  /* standard (textbook) */
-#define GLP_RT_HAR      0x22  /* two-pass Harris' ratio test */
-      double tol_bnd;         /* spx.tol_bnd */
-      double tol_dj;          /* spx.tol_dj */
-      double tol_piv;         /* spx.tol_piv */
-      double obj_ll;          /* spx.obj_ll */
-      double obj_ul;          /* spx.obj_ul */
-      int it_lim;             /* spx.it_lim */
-      int tm_lim;             /* spx.tm_lim (milliseconds) */
-      int out_frq;            /* spx.out_frq */
-      int out_dly;            /* spx.out_dly (milliseconds) */
-      int presolve;           /* enable/disable using LP presolver */
-      double foo_bar[36];     /* (reserved) */
+{                               /* simplex method control parameters */
+  int msg_lev;                  /* message level: */
+#define GLP_MSG_OFF        0    /* no output */
+#define GLP_MSG_ERR        1    /* warning and error messages only */
+#define GLP_MSG_ON         2    /* normal output */
+#define GLP_MSG_ALL        3    /* full output */
+#define GLP_MSG_DBG        4    /* debug output */
+  int meth;                     /* simplex method option: */
+#define GLP_PRIMAL         1    /* use primal simplex */
+#define GLP_DUALP          2    /* use dual; if it fails, use primal */
+#define GLP_DUAL           3    /* use dual simplex */
+  int pricing;                  /* pricing technique: */
+#define GLP_PT_STD      0x11    /* standard (Dantzig rule) */
+#define GLP_PT_PSE      0x22    /* projected steepest edge */
+  int r_test;                   /* ratio test technique: */
+#define GLP_RT_STD      0x11    /* standard (textbook) */
+#define GLP_RT_HAR      0x22    /* two-pass Harris' ratio test */
+  double tol_bnd;               /* spx.tol_bnd */
+  double tol_dj;                /* spx.tol_dj */
+  double tol_piv;               /* spx.tol_piv */
+  double obj_ll;                /* spx.obj_ll */
+  double obj_ul;                /* spx.obj_ul */
+  int it_lim;                   /* spx.it_lim */
+  int tm_lim;                   /* spx.tm_lim (milliseconds) */
+  int out_frq;                  /* spx.out_frq */
+  int out_dly;                  /* spx.out_dly (milliseconds) */
+  int presolve;                 /* enable/disable using LP presolver */
+  double foo_bar[36];           /* (reserved) */
 } glp_smcp;
 
 /* optimization direction flag: */
-#define GLP_MIN            1  /* minimization */
-#define GLP_MAX            2  /* maximization */
+#define GLP_MIN            1    /* minimization */
+#define GLP_MAX            2    /* maximization */
 
 /* kind of structural variable: */
-#define GLP_CV             1  /* continuous variable */
-#define GLP_IV             2  /* integer variable */
-#define GLP_BV             3  /* binary variable */
+#define GLP_CV             1    /* continuous variable */
+#define GLP_IV             2    /* integer variable */
+#define GLP_BV             3    /* binary variable */
 
 /* type of auxiliary/structural variable: */
-#define GLP_FR             1  /* free variable */
-#define GLP_LO             2  /* variable with lower bound */
-#define GLP_UP             3  /* variable with upper bound */
-#define GLP_DB             4  /* double-bounded variable */
-#define GLP_FX             5  /* fixed variable */
+#define GLP_FR             1    /* free variable */
+#define GLP_LO             2    /* variable with lower bound */
+#define GLP_UP             3    /* variable with upper bound */
+#define GLP_DB             4    /* double-bounded variable */
+#define GLP_FX             5    /* fixed variable */
 
 /* solution indicator: */
-#define GLP_SOL            1  /* basic solution */
-#define GLP_IPT            2  /* interior-point solution */
-#define GLP_MIP            3  /* mixed integer solution */
+#define GLP_SOL            1    /* basic solution */
+#define GLP_IPT            2    /* interior-point solution */
+#define GLP_MIP            3    /* mixed integer solution */
 
 /* solution status: */
-#define GLP_UNDEF          1  /* solution is undefined */
-#define GLP_FEAS           2  /* solution is feasible */
-#define GLP_INFEAS         3  /* solution is infeasible */
-#define GLP_NOFEAS         4  /* no feasible solution exists */
-#define GLP_OPT            5  /* solution is optimal */
-#define GLP_UNBND          6  /* solution is unbounded */
+#define GLP_UNDEF          1    /* solution is undefined */
+#define GLP_FEAS           2    /* solution is feasible */
+#define GLP_INFEAS         3    /* solution is infeasible */
+#define GLP_NOFEAS         4    /* no feasible solution exists */
+#define GLP_OPT            5    /* solution is optimal */
+#define GLP_UNBND          6    /* solution is unbounded */
 
 /* return codes: */
-#define GLP_EBADB       0x01  /* invalid basis */
-#define GLP_ESING       0x02  /* singular matrix */
-#define GLP_ECOND       0x03  /* ill-conditioned matrix */
-#define GLP_EBOUND      0x04  /* invalid bounds */
-#define GLP_EFAIL       0x05  /* solver failed */
-#define GLP_EOBJLL      0x06  /* objective lower limit reached */
-#define GLP_EOBJUL      0x07  /* objective upper limit reached */
-#define GLP_EITLIM      0x08  /* iteration limit exceeded */
-#define GLP_ETMLIM      0x09  /* time limit exceeded */
-#define GLP_ENOPFS      0x0A  /* no primal feasible solution */
-#define GLP_ENODFS      0x0B  /* no dual feasible solution */
-#define GLP_EROOT       0x0C  /* root LP optimum not provided */
-#define GLP_ESTOP       0x0D  /* search terminated by application */
-#define GLP_EMIPGAP     0x0E  /* relative mip gap tolerance reached */
-#define GLP_ENOFEAS     0x0F  /* no primal/dual feasible solution */
-#define GLP_ENOCVG      0x10  /* no convergence */
-#define GLP_EINSTAB     0x11  /* numerical instability */
-#define GLP_EDATA       0x12  /* invalid data */
-#define GLP_ERANGE      0x13  /* result out of range */
+#define GLP_EBADB       0x01    /* invalid basis */
+#define GLP_ESING       0x02    /* singular matrix */
+#define GLP_ECOND       0x03    /* ill-conditioned matrix */
+#define GLP_EBOUND      0x04    /* invalid bounds */
+#define GLP_EFAIL       0x05    /* solver failed */
+#define GLP_EOBJLL      0x06    /* objective lower limit reached */
+#define GLP_EOBJUL      0x07    /* objective upper limit reached */
+#define GLP_EITLIM      0x08    /* iteration limit exceeded */
+#define GLP_ETMLIM      0x09    /* time limit exceeded */
+#define GLP_ENOPFS      0x0A    /* no primal feasible solution */
+#define GLP_ENODFS      0x0B    /* no dual feasible solution */
+#define GLP_EROOT       0x0C    /* root LP optimum not provided */
+#define GLP_ESTOP       0x0D    /* search terminated by application */
+#define GLP_EMIPGAP     0x0E    /* relative mip gap tolerance reached */
+#define GLP_ENOFEAS     0x0F    /* no primal/dual feasible solution */
+#define GLP_ENOCVG      0x10    /* no convergence */
+#define GLP_EINSTAB     0x11    /* numerical instability */
+#define GLP_EDATA       0x12    /* invalid data */
+#define GLP_ERANGE      0x13    /* result out of range */
 
 /* enable/disable flag: */
-#define GLP_ON             1  /* enable something */
-#define GLP_OFF            0  /* disable something */
+#define GLP_ON             1    /* enable something */
+#define GLP_OFF            0    /* disable something */
 
 #endif
 
@@ -176,10 +179,11 @@ typedef struct
  */
 
 
-void * _lp_create_prob ( void )
+void *
+_lp_create_prob (void)
 {
 #if HAVE_LIBGLPK
-  return glp_create_prob( );
+  return glp_create_prob ();
 #else
   // Function not implemented
   GNUNET_break (0);
@@ -187,7 +191,8 @@ void * _lp_create_prob ( void )
   return NULL;
 }
 
-void _lp_set_obj_dir (glp_prob *P, int dir)
+void
+_lp_set_obj_dir (glp_prob *P, int dir)
 {
 #if HAVE_LIBGLPK
   return glp_set_obj_dir (P, dir);
@@ -197,20 +202,22 @@ void _lp_set_obj_dir (glp_prob *P, int dir)
 #endif
 }
 
-void _lp_set_prob_name (glp_prob *P, const char *name)
+void
+_lp_set_prob_name (glp_prob *P, const char *name)
 {
 #if HAVE_LIBGLPK
-  glp_set_prob_name(P, name);
+  glp_set_prob_name (P, name);
 #else
   // Function not implemented
   GNUNET_break (0);
 #endif
 }
 
-int _lp_add_cols (glp_prob *P, int ncs)
+int
+_lp_add_cols (glp_prob *P, int ncs)
 {
 #if HAVE_LIBGLPK
-  return glp_add_cols(P, ncs);
+  return glp_add_cols (P, ncs);
 #else
   // Function not implemented
   GNUNET_break (0);
@@ -218,7 +225,8 @@ int _lp_add_cols (glp_prob *P, int ncs)
   return 0;
 }
 
-int _lp_add_rows (glp_prob *P, int nrs)
+int
+_lp_add_rows (glp_prob *P, int nrs)
 {
 #if HAVE_LIBGLPK
   return glp_add_rows (P, nrs);
@@ -230,27 +238,30 @@ int _lp_add_rows (glp_prob *P, int nrs)
 }
 
 
-void _lp_set_row_bnds (glp_prob *P, int i, int type, double lb, double ub)
+void
+_lp_set_row_bnds (glp_prob *P, int i, int type, double lb, double ub)
 {
 #if HAVE_LIBGLPK
-  glp_set_row_bnds(P, i , type, lb, ub);
+  glp_set_row_bnds (P, i, type, lb, ub);
 #else
   // Function not implemented
   GNUNET_break (0);
 #endif
 }
 
-void _lp_init_smcp (void * parm)
+void
+_lp_init_smcp (void *parm)
 {
 #if HAVE_LIBGLPK
-  glp_init_smcp(parm);
+  glp_init_smcp (parm);
 #else
   // Function not implemented
   GNUNET_break (0);
 #endif
 }
 
-void _lp_set_col_name (glp_prob *P, int j, const char *name)
+void
+_lp_set_col_name (glp_prob *P, int j, const char *name)
 {
 #if HAVE_LIBGLPK
   glp_set_col_name (P, j, name);
@@ -260,28 +271,30 @@ void _lp_set_col_name (glp_prob *P, int j, const char *name)
 #endif
 }
 
-void _lp_set_col_bnds (glp_prob *P, int j, int type, double lb,
-      double ub)
+void
+_lp_set_col_bnds (glp_prob *P, int j, int type, double lb, double ub)
 {
 #if HAVE_LIBGLPK
-  glp_set_col_bnds(P, j, type, lb, ub);
+  glp_set_col_bnds (P, j, type, lb, ub);
 #else
   // Function not implemented
   GNUNET_break (0);
 #endif
 }
 
-void _lp_set_obj_coef(glp_prob *P, int j, double coef)
+void
+_lp_set_obj_coef (glp_prob *P, int j, double coef)
 {
 #if HAVE_LIBGLPK
-  glp_set_obj_coef(P, j, coef);
+  glp_set_obj_coef (P, j, coef);
 #else
   // Function not implemented
   GNUNET_break (0);
 #endif
 }
 
-void _lp_delete_prob (void * P)
+void
+_lp_delete_prob (void *P)
 {
 #if HAVE_LIBGLPK
   glp_delete_prob (P);
@@ -291,7 +304,8 @@ void _lp_delete_prob (void * P)
 #endif
 }
 
-static int _lp_simplex(glp_prob *P, void *parm)
+static int
+_lp_simplex (glp_prob *P, void *parm)
 {
 #if HAVE_LIBGLPK
   return glp_simplex (P, parm);
@@ -302,19 +316,21 @@ static int _lp_simplex(glp_prob *P, void *parm)
   return 0;
 }
 
-static void _lp_load_matrix (glp_prob *P, int ne, const int ia[],
-      const int ja[], const double ar[])
+static void
+_lp_load_matrix (glp_prob *P, int ne, const int ia[],
+                 const int ja[], const double ar[])
 {
 #if HAVE_LIBGLPK
-  glp_load_matrix(P, ne, ia, ja, ar);
+  glp_load_matrix (P, ne, ia, ja, ar);
 #else
   // Function not implemented
   GNUNET_break (0);
 #endif
 }
 
-static void _lp_set_mat_row (glp_prob *P, int i, int len, const int ind[],
-      const double val[])
+static void
+_lp_set_mat_row (glp_prob *P, int i, int len, const int ind[],
+                 const double val[])
 {
 #if HAVE_LIBGLPK
   glp_set_mat_row (P, i, len, ind, val);
@@ -324,10 +340,11 @@ static void _lp_set_mat_row (glp_prob *P, int i, int len, const int ind[],
 #endif
 }
 
-static int _lp_write_lp (glp_prob *P, const void *parm, const char *fname)
+static int
+_lp_write_lp (glp_prob *P, const void *parm, const char *fname)
 {
 #if HAVE_LIBGLPK
-  return glp_write_lp ( P, parm, fname);
+  return glp_write_lp (P, parm, fname);
 #else
   // Function not implemented
   GNUNET_break (0);
@@ -335,7 +352,8 @@ static int _lp_write_lp (glp_prob *P, const void *parm, const char *fname)
   return 0;
 }
 
-static void _lp_init_iocp (void *parm)
+static void
+_lp_init_iocp (void *parm)
 {
 #if HAVE_LIBGLPK
   glp_init_iocp (parm);
@@ -345,7 +363,8 @@ static void _lp_init_iocp (void *parm)
 #endif
 }
 
-static int _lp_intopt (glp_prob *P, const void *parm)
+static int
+_lp_intopt (glp_prob *P, const void *parm)
 {
 #if HAVE_LIBGLPK
   return glp_intopt (P, parm);
@@ -356,7 +375,8 @@ static int _lp_intopt (glp_prob *P, const void *parm)
   return 0;
 }
 
-static int _lp_get_status (glp_prob *P)
+static int
+_lp_get_status (glp_prob *P)
 {
 #if HAVE_LIBGLPK
   return glp_get_status (P);
@@ -367,7 +387,8 @@ static int _lp_get_status (glp_prob *P)
   return 0;
 }
 
-static int _lp_mip_status (glp_prob *P)
+static int
+_lp_mip_status (glp_prob *P)
 {
 #if HAVE_LIBGLPK
   return glp_mip_status (P);
@@ -378,7 +399,8 @@ static int _lp_mip_status (glp_prob *P)
   return 0;
 }
 
-static void _lp_set_col_kind (glp_prob *P, int j, int kind)
+static void
+_lp_set_col_kind (glp_prob *P, int j, int kind)
 {
 #if HAVE_LIBGLPK
   glp_set_col_kind (P, j, kind);
@@ -388,7 +410,8 @@ static void _lp_set_col_kind (glp_prob *P, int j, int kind)
 #endif
 }
 
-static void _lp_free_env (void)
+static void
+_lp_free_env (void)
 {
 #if HAVE_LIBGLPK
   glp_free_env ();
@@ -398,7 +421,8 @@ static void _lp_free_env (void)
 #endif
 }
 
-static const char * _lp_get_col_name ( glp_prob *P, int j)
+static const char *
+_lp_get_col_name (glp_prob *P, int j)
 {
 #if HAVE_LIBGLPK
   return glp_get_col_name (P, j);
@@ -409,7 +433,8 @@ static const char * _lp_get_col_name ( glp_prob *P, int j)
   return NULL;
 }
 
-static double _lp_mip_obj_val (glp_prob *P)
+static double
+_lp_mip_obj_val (glp_prob *P)
 {
 #if HAVE_LIBGLPK
   return glp_mip_obj_val (P);
@@ -421,10 +446,11 @@ static double _lp_mip_obj_val (glp_prob *P)
 }
 
 
-static double _lp_get_col_prim (glp_prob *P, int j)
+static double
+_lp_get_col_prim (glp_prob *P, int j)
 {
 #if HAVE_LIBGLPK
-  return glp_get_col_prim (P , j);
+  return glp_get_col_prim (P, j);
 #else
   // Function not implemented
   GNUNET_break (0);
@@ -432,7 +458,8 @@ static double _lp_get_col_prim (glp_prob *P, int j)
   return 0.0;
 }
 
-static int _lp_print_sol(glp_prob *P, const char *fname)
+static int
+_lp_print_sol (glp_prob *P, const char *fname)
 {
 #if HAVE_LIBGLPK
 #else
@@ -447,24 +474,27 @@ static int _lp_print_sol(glp_prob *P, const char *fname)
  */
 
 static void _dummy2 ();
-static void _dummy ()
+static void
+_dummy ()
 {
   return;
   _lp_get_col_name (NULL, 0);
   _lp_mip_obj_val (NULL);
   _lp_get_col_prim (NULL, 0);
-  _lp_set_mat_row(NULL,0,0,NULL,NULL);
-  _dummy2();
+  _lp_set_mat_row (NULL, 0, 0, NULL, NULL);
+  _dummy2 ();
 }
 
 
 
-static void _dummy2 ()
+static void
+_dummy2 ()
 {
   ats_modify_problem_state (NULL, 0);
   qm[1].atis_index = 0;
-  _dummy();
+  _dummy ();
   int t = ATS_COST_UPDATED + ATS_MODIFIED + ATS_NEW;
+
   t++;
 }
 
@@ -479,19 +509,20 @@ static void _dummy2 ()
  * @return
  */
 
-struct ATS_Handle * ats_init (double D,
-                              double U,
-                              double R,
-                              int v_b_min,
-                              int v_n_min,
-                              int max_iterations,
-                              struct GNUNET_TIME_Relative max_duration,
-                              GNUNET_TRANSPORT_ATS_AddressNotification address_not,
-                              GNUNET_TRANSPORT_ATS_ResultCallback res_cb)
+struct ATS_Handle *
+ats_init (double D,
+          double U,
+          double R,
+          int v_b_min,
+          int v_n_min,
+          int max_iterations,
+          struct GNUNET_TIME_Relative max_duration,
+          GNUNET_TRANSPORT_ATS_AddressNotification address_not,
+          GNUNET_TRANSPORT_ATS_ResultCallback res_cb)
 {
-  struct ATS_Handle * ats = NULL;
+  struct ATS_Handle *ats = NULL;
 
-  ats = GNUNET_malloc(sizeof (struct ATS_Handle));
+  ats = GNUNET_malloc (sizeof (struct ATS_Handle));
 
   ats->prob = NULL;
 
@@ -507,7 +538,7 @@ struct ATS_Handle * ats_init (double D,
   ats->v_b_min = v_b_min;
   ats->v_n_min = v_n_min;
   ats->dump_min_peers = 0;
-  ats->dump_min_addr =  0;
+  ats->dump_min_addr = 0;
   ats->dump_overwrite = GNUNET_NO;
   ats->mechanisms = NULL;
   ats->peers = NULL;
@@ -529,181 +560,165 @@ struct ATS_Handle * ats_init (double D,
  * @param stat result struct
  * @return GNUNET_SYSERR if glpk is not available, number of mechanisms used
  */
-int ats_create_problem (struct ATS_Handle *ats,
-                        struct ATS_internals *stat,
-                        struct ATS_peer *peers,
-                        int c_p,
-                        struct ATS_mechanism *mechanisms,
-                        int c_m)
+int
+ats_create_problem (struct ATS_Handle *ats,
+                    struct ATS_internals *stat,
+                    struct ATS_peer *peers,
+                    int c_p, struct ATS_mechanism *mechanisms, int c_m)
 {
   if ((c_p == 0) || (c_m == 0))
     return GNUNET_SYSERR;
 
-  ats->prob = _lp_create_prob();
+  ats->prob = _lp_create_prob ();
 
   int c;
   int c_c_ressources = available_ressources;
   int c_q_metrics = available_quality_metrics;
 
   double M = VERY_BIG_DOUBLE_VALUE;
-  double Q[c_q_metrics+1];
-  for (c=1; c<=c_q_metrics; c++)
+  double Q[c_q_metrics + 1];
+
+  for (c = 1; c <= c_q_metrics; c++)
   {
-          Q[c] = 1;
+    Q[c] = 1;
   }
 
   if (ats->v_n_min > c_p)
-          ats->v_n_min = c_p;
+    ats->v_n_min = c_p;
 #if VERBOSE_ATS
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Creating problem with: %i peers, %i mechanisms, %i resource entries, %i quality metrics \n",
-      c_p,
-      c_m,
-      c_c_ressources,
-      c_q_metrics);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Creating problem with: %i peers, %i mechanisms, %i resource entries, %i quality metrics \n",
+              c_p, c_m, c_c_ressources, c_q_metrics);
 #endif
 
-  int size =  1 + 3 + 10 *c_m + c_p +
-              (c_q_metrics*c_m)+ c_q_metrics + c_c_ressources * c_m ;
+  int size = 1 + 3 + 10 * c_m + c_p +
+      (c_q_metrics * c_m) + c_q_metrics + c_c_ressources * c_m;
   int row_index;
-  int array_index=1;
-  int * ia = GNUNET_malloc (size * sizeof (int));
-  int * ja = GNUNET_malloc (size * sizeof (int));
-  double * ar = GNUNET_malloc(size* sizeof (double));
+  int array_index = 1;
+  int *ia = GNUNET_malloc (size * sizeof (int));
+  int *ja = GNUNET_malloc (size * sizeof (int));
+  double *ar = GNUNET_malloc (size * sizeof (double));
 
   _lp_set_prob_name (ats->prob, "gnunet ats bandwidth distribution");
-  _lp_set_obj_dir(ats->prob, GLP_MAX);
+  _lp_set_obj_dir (ats->prob, GLP_MAX);
 
   /* adding columns */
-  char * name;
-  _lp_add_cols(ats->prob, 2 * c_m);
+  char *name;
+
+  _lp_add_cols (ats->prob, 2 * c_m);
   /* adding b_t cols */
-  for (c=1; c <= c_m; c++)
+  for (c = 1; c <= c_m; c++)
   {
-    GNUNET_asprintf(&name,
-        "p_%s_b%i",GNUNET_i2s(&(mechanisms[c].peer->peer)), c);
-    _lp_set_col_name(ats->prob, c, name);
+    GNUNET_asprintf (&name,
+                     "p_%s_b%i", GNUNET_i2s (&(mechanisms[c].peer->peer)), c);
+    _lp_set_col_name (ats->prob, c, name);
     GNUNET_free (name);
-    _lp_set_col_bnds(ats->prob, c, GLP_LO, 0.0, 0.0);
-    _lp_set_col_kind(ats->prob, c, GLP_CV);
-    _lp_set_obj_coef(ats->prob, c, 0);
+    _lp_set_col_bnds (ats->prob, c, GLP_LO, 0.0, 0.0);
+    _lp_set_col_kind (ats->prob, c, GLP_CV);
+    _lp_set_obj_coef (ats->prob, c, 0);
   }
 
   /* adding n_t cols */
-  for (c=c_m+1; c <= 2*c_m; c++)
+  for (c = c_m + 1; c <= 2 * c_m; c++)
   {
-    GNUNET_asprintf(&name,
-        "p_%s_n%i",GNUNET_i2s(&(mechanisms[c-c_m].peer->peer)),(c-c_m));
-    _lp_set_col_name(ats->prob, c, name);
+    GNUNET_asprintf (&name,
+                     "p_%s_n%i", GNUNET_i2s (&(mechanisms[c - c_m].peer->peer)),
+                     (c - c_m));
+    _lp_set_col_name (ats->prob, c, name);
     GNUNET_free (name);
-    _lp_set_col_bnds(ats->prob, c, GLP_DB, 0.0, 1.0);
-    _lp_set_col_kind(ats->prob, c, GLP_IV);
-    _lp_set_obj_coef(ats->prob, c, 0);
+    _lp_set_col_bnds (ats->prob, c, GLP_DB, 0.0, 1.0);
+    _lp_set_col_kind (ats->prob, c, GLP_IV);
+    _lp_set_obj_coef (ats->prob, c, 0);
   }
 
   /* feasibility constraints */
-  /* Constraint 1: one address per peer*/
+  /* Constraint 1: one address per peer */
   row_index = 1;
 
-  _lp_add_rows(ats->prob, c_p);
+  _lp_add_rows (ats->prob, c_p);
 
-  for (c=1; c<=c_p; c++)
+  for (c = 1; c <= c_p; c++)
   {
 #if VERBOSE_ATS
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
-          row_index);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
 #endif
 
-      _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 1.0, 1.0);
-      struct ATS_mechanism *m = peers[c].m_head;
-      while (m!=NULL)
-      {
-        ia[array_index] = row_index;
-        ja[array_index] = (c_m + m->col_index);
-        ar[array_index] = 1;
+    _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 1.0, 1.0);
+    struct ATS_mechanism *m = peers[c].m_head;
+
+    while (m != NULL)
+    {
+      ia[array_index] = row_index;
+      ja[array_index] = (c_m + m->col_index);
+      ar[array_index] = 1;
 #if VERBOSE_ATS
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-            array_index,
-            ia[array_index],
-            ja[array_index],
-            ar[array_index]);
-#endif
-        array_index++;
-        m = m->next;
-      }
-      row_index++;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                  array_index,
+                  ia[array_index], ja[array_index], ar[array_index]);
+#endif
+      array_index++;
+      m = m->next;
+    }
+    row_index++;
   }
 
   /* Constraint 2: only active mechanism gets bandwidth assigned */
-  _lp_add_rows(ats->prob, c_m);
-  for (c=1; c<=c_m; c++)
+  _lp_add_rows (ats->prob, c_m);
+  for (c = 1; c <= c_m; c++)
   {
-          /* b_t - n_t * M <= 0 */
+    /* b_t - n_t * M <= 0 */
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
-              row_index);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
 #endif
-          _lp_set_row_bnds(ats->prob, row_index, GLP_UP, 0.0, 0.0);
-          ia[array_index] = row_index;
-          ja[array_index] = mechanisms[c].col_index;
-          ar[array_index] = 1;
+    _lp_set_row_bnds (ats->prob, row_index, GLP_UP, 0.0, 0.0);
+    ia[array_index] = row_index;
+    ja[array_index] = mechanisms[c].col_index;
+    ar[array_index] = 1;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-              array_index,
-              ia[array_index],
-              ja[array_index],
-              ar[array_index]);
-#endif
-          array_index++;
-          ia[array_index] = row_index;
-          ja[array_index] = c_m + mechanisms[c].col_index;
-          ar[array_index] = -M;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+    array_index++;
+    ia[array_index] = row_index;
+    ja[array_index] = c_m + mechanisms[c].col_index;
+    ar[array_index] = -M;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-              array_index,
-              ia[array_index],
-              ja[array_index],
-              ar[array_index]);
-#endif
-          array_index++;
-          row_index ++;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+    array_index++;
+    row_index++;
   }
 
-  /* Constraint 3: minimum bandwidth*/
-  _lp_add_rows(ats->prob, c_m);
+  /* Constraint 3: minimum bandwidth */
+  _lp_add_rows (ats->prob, c_m);
 
-  for (c=1; c<=c_m; c++)
+  for (c = 1; c <= c_m; c++)
   {
-          /* b_t - n_t * b_min <= 0 */
+    /* b_t - n_t * b_min <= 0 */
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
-              row_index);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
 #endif
 #if HAVE_LIBGLPK
-          _lp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
+    _lp_set_row_bnds (ats->prob, row_index, GLP_LO, 0.0, 0.0);
 #endif
-          ia[array_index] = row_index;
-          ja[array_index] = mechanisms[c].col_index;
-          ar[array_index] = 1;
+    ia[array_index] = row_index;
+    ja[array_index] = mechanisms[c].col_index;
+    ar[array_index] = 1;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-              array_index,
-              ia[array_index],
-              ja[array_index],
-              ar[array_index]);
-#endif
-          array_index++;
-          ia[array_index] = row_index;
-          ja[array_index] = c_m + mechanisms[c].col_index;
-          ar[array_index] = -ats->v_b_min;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+    array_index++;
+    ia[array_index] = row_index;
+    ja[array_index] = c_m + mechanisms[c].col_index;
+    ar[array_index] = -ats->v_b_min;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-              array_index,
-              ia[array_index],
-              ja[array_index],
-              ar[array_index]);
-#endif
-          array_index++;
-          row_index ++;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+    array_index++;
+    row_index++;
   }
   int c2;
 
@@ -711,69 +726,63 @@ int ats_create_problem (struct ATS_Handle *ats,
   /* V cr: bt * ct_r <= cr_max
    * */
 
-  _lp_add_rows(ats->prob, available_ressources);
+  _lp_add_rows (ats->prob, available_ressources);
 
   double ct_max = VERY_BIG_DOUBLE_VALUE;
   double ct_min = 0.0;
 
   stat->begin_cr = array_index;
 
-  for (c=0; c<available_ressources; c++)
+  for (c = 0; c < available_ressources; c++)
   {
-      ct_max = ressources[c].c_max;
-      ct_min = ressources[c].c_min;
+    ct_max = ressources[c].c_max;
+    ct_min = ressources[c].c_min;
 #if VERBOSE_ATS
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
-          row_index,
-          ct_min,
-          ct_max);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
+                row_index, ct_min, ct_max);
 #endif
 #if HAVE_LIBGLPK
-      _lp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
+    _lp_set_row_bnds (ats->prob, row_index, GLP_DB, ct_min, ct_max);
 #endif
-      for (c2=1; c2<=c_m; c2++)
-      {
-          double value = 0;
-          ia[array_index] = row_index;
-          ja[array_index] = c2;
-          value = mechanisms[c2].ressources[c].c;
-          ar[array_index] = value;
+    for (c2 = 1; c2 <= c_m; c2++)
+    {
+      double value = 0;
+
+      ia[array_index] = row_index;
+      ja[array_index] = c2;
+      value = mechanisms[c2].ressources[c].c;
+      ar[array_index] = value;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-              array_index, ia[array_index],
-              ja[array_index],
-              ar[array_index]);
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                  array_index, ia[array_index],
+                  ja[array_index], ar[array_index]);
 #endif
-          array_index++;
-      }
-      row_index ++;
+      array_index++;
+    }
+    row_index++;
   }
   stat->end_cr = array_index--;
 
-  /* Constraint 5: min number of connections*/
-  _lp_add_rows(ats->prob, 1);
+  /* Constraint 5: min number of connections */
+  _lp_add_rows (ats->prob, 1);
 
-  for (c=1; c<=c_m; c++)
+  for (c = 1; c <= c_m; c++)
   {
-          // b_t - n_t * b_min >= 0
+    // b_t - n_t * b_min >= 0
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
-              row_index);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
 #endif
-          _lp_set_row_bnds(ats->prob, row_index, GLP_LO, ats->v_n_min, 0.0);
-          ia[array_index] = row_index;
-          ja[array_index] = c_m + mechanisms[c].col_index;
-          ar[array_index] = 1;
+    _lp_set_row_bnds (ats->prob, row_index, GLP_LO, ats->v_n_min, 0.0);
+    ia[array_index] = row_index;
+    ja[array_index] = c_m + mechanisms[c].col_index;
+    ar[array_index] = 1;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-              array_index,
-              ia[array_index],
-              ja[array_index],
-              ar[array_index]);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
 #endif
-          array_index++;
+    array_index++;
   }
-  row_index ++;
+  row_index++;
 
   // optimisation constraints
 
@@ -781,29 +790,27 @@ int ats_create_problem (struct ATS_Handle *ats,
 
   // Constraint 6: optimize for diversity
   int col_d;
-  col_d = _lp_add_cols(ats->prob, 1);
 
-  _lp_set_col_name(ats->prob, col_d, "d");
-  _lp_set_obj_coef(ats->prob, col_d, ats->D);
-  _lp_set_col_bnds(ats->prob, col_d, GLP_LO, 0.0, 0.0);
-  _lp_add_rows(ats->prob, 1);
-  _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
+  col_d = _lp_add_cols (ats->prob, 1);
+
+  _lp_set_col_name (ats->prob, col_d, "d");
+  _lp_set_obj_coef (ats->prob, col_d, ats->D);
+  _lp_set_col_bnds (ats->prob, col_d, GLP_LO, 0.0, 0.0);
+  _lp_add_rows (ats->prob, 1);
+  _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
 
   stat->col_d = col_d;
 #if VERBOSE_ATS
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
 #endif
-  for (c=1; c<=c_m; c++)
+  for (c = 1; c <= c_m; c++)
   {
     ia[array_index] = row_index;
     ja[array_index] = c_m + mechanisms[c].col_index;
     ar[array_index] = 1;
 #if VERBOSE_ATS
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-        array_index,
-        ia[array_index],
-        ja[array_index],
-        ar[array_index]);
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
 #endif
     array_index++;
   }
@@ -812,122 +819,120 @@ int ats_create_problem (struct ATS_Handle *ats,
   ar[array_index] = -1;
 #if VERBOSE_ATS
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-      array_index,
-      ia[array_index],
-      ja[array_index],
-      ar[array_index]);
+              array_index, ia[array_index], ja[array_index], ar[array_index]);
 #endif
   array_index++;
-  row_index ++;
+  row_index++;
 
   // Constraint 7: optimize for quality
   int col_qm;
-  col_qm = _lp_add_cols(ats->prob, c_q_metrics);
+
+  col_qm = _lp_add_cols (ats->prob, c_q_metrics);
 
   stat->col_qm = col_qm;
   //GNUNET_assert (col_qm == (2*c_mechs) + 3 + 1);
-  for (c=0; c< c_q_metrics; c++)
+  for (c = 0; c < c_q_metrics; c++)
   {
-    GNUNET_asprintf(&name, "Q_%s",qm[c].name);
+    GNUNET_asprintf (&name, "Q_%s", qm[c].name);
     _lp_set_col_name (ats->prob, col_qm + c, name);
     _lp_set_col_bnds (ats->prob, col_qm + c, GLP_LO, 0.0, 0.0);
     GNUNET_free (name);
     _lp_set_obj_coef (ats->prob, col_qm + c, Q[c]);
   }
 
-  _lp_add_rows(ats->prob, available_quality_metrics);
+  _lp_add_rows (ats->prob, available_quality_metrics);
 
   stat->begin_qm = row_index;
-  for (c=1; c <= c_q_metrics; c++)
+  for (c = 1; c <= c_q_metrics; c++)
   {
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
-              row_index);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
 #endif
-      double value = 1;
-      _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
-      for (c2=1; c2<=c_m; c2++)
+    double value = 1;
+
+    _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+    for (c2 = 1; c2 <= c_m; c2++)
+    {
+      ia[array_index] = row_index;
+      ja[array_index] = c2;
+      if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
       {
-          ia[array_index] = row_index;
-          ja[array_index] = c2;
-          if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
-          {
-            double v0 = 0, v1 = 0, v2 = 0;
-            v0 = mechanisms[c2].quality[c-1].values[0];
-            if (v1 < 1) v0 = 0.1;
-              v1 = mechanisms[c2].quality[c-1].values[1];
-            if (v1 < 1) v0 = 0.1;
-              v2 = mechanisms[c2].quality[c-1].values[2];
-            if (v1 < 1) v0 = 0.1;
-              value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
-            value = 1;
-          }
-          if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
-          {
-            double v0 = 0, v1 = 0, v2 = 0;
-            v0 = mechanisms[c2].quality[c-1].values[0];
-            if (v0 < 1) v0 = 1;
-              v1 = mechanisms[c2].quality[c-1].values[1];
-            if (v1 < 1) v1 = 1;
-              v2 = mechanisms[c2].quality[c-1].values[2];
-            if (v2 < 1) v2 = 1;
-              value =  (v0 + 2 * v1 + 3 * v2) / 6.0;
-            if (value >= 1)
-              value =  (double) 10 / value;
-            else
-              value = 10;
-          }
-          ar[array_index] = (mechanisms[c2].peer->f) * value ;
-#if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
-              array_index,
-              qm[c-1].name,
-              ia[array_index],
-              ja[array_index],
-              ar[array_index]);
-#endif
-          array_index++;
+        double v0 = 0, v1 = 0, v2 = 0;
+
+        v0 = mechanisms[c2].quality[c - 1].values[0];
+        if (v1 < 1)
+          v0 = 0.1;
+        v1 = mechanisms[c2].quality[c - 1].values[1];
+        if (v1 < 1)
+          v0 = 0.1;
+        v2 = mechanisms[c2].quality[c - 1].values[2];
+        if (v1 < 1)
+          v0 = 0.1;
+        value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
+        value = 1;
       }
-      ia[array_index] = row_index;
-      ja[array_index] = col_qm + c - 1;
-      ar[array_index] = -1;
+      if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
+      {
+        double v0 = 0, v1 = 0, v2 = 0;
+
+        v0 = mechanisms[c2].quality[c - 1].values[0];
+        if (v0 < 1)
+          v0 = 1;
+        v1 = mechanisms[c2].quality[c - 1].values[1];
+        if (v1 < 1)
+          v1 = 1;
+        v2 = mechanisms[c2].quality[c - 1].values[2];
+        if (v2 < 1)
+          v2 = 1;
+        value = (v0 + 2 * v1 + 3 * v2) / 6.0;
+        if (value >= 1)
+          value = (double) 10 / value;
+        else
+          value = 10;
+      }
+      ar[array_index] = (mechanisms[c2].peer->f) * value;
 #if VERBOSE_ATS
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-          array_index,
-          ia[array_index],
-          ja[array_index],
-          ar[array_index]);
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
+                  array_index,
+                  qm[c - 1].name,
+                  ia[array_index], ja[array_index], ar[array_index]);
 #endif
       array_index++;
-      row_index++;
+    }
+    ia[array_index] = row_index;
+    ja[array_index] = col_qm + c - 1;
+    ar[array_index] = -1;
+#if VERBOSE_ATS
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+    array_index++;
+    row_index++;
   }
-  stat->end_qm = row_index-1;
+  stat->end_qm = row_index - 1;
 
   // Constraint 8: optimize bandwidth utility
   int col_u;
 
-  col_u = _lp_add_cols(ats->prob, 1);
+  col_u = _lp_add_cols (ats->prob, 1);
 
-  _lp_set_col_name(ats->prob, col_u, "u");
-  _lp_set_obj_coef(ats->prob, col_u, ats->U);
-  _lp_set_col_bnds(ats->prob, col_u, GLP_LO, 0.0, 0.0);
-  _lp_add_rows(ats->prob, 1);
+  _lp_set_col_name (ats->prob, col_u, "u");
+  _lp_set_obj_coef (ats->prob, col_u, ats->U);
+  _lp_set_col_bnds (ats->prob, col_u, GLP_LO, 0.0, 0.0);
+  _lp_add_rows (ats->prob, 1);
   stat->col_u = col_u;
 #if VERBOSE_ATS
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
 #endif
-  _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
-  for (c=1; c<=c_m; c++)
+  _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+  for (c = 1; c <= c_m; c++)
   {
     ia[array_index] = row_index;
     ja[array_index] = c;
     ar[array_index] = mechanisms[c].peer->f;
 #if VERBOSE_ATS
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-        array_index,
-        ia[array_index],
-        ja[array_index],
-        ar[array_index]);
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
 #endif
     array_index++;
   }
@@ -936,40 +941,37 @@ int ats_create_problem (struct ATS_Handle *ats,
   ar[array_index] = -1;
 #if VERBOSE_ATS
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-      array_index, ia[array_index],
-      ja[array_index],
-      ar[array_index]);
+              array_index, ia[array_index], ja[array_index], ar[array_index]);
 #endif
 
   array_index++;
-  row_index ++;
+  row_index++;
 
   // Constraint 9: optimize relativity
   int col_r;
 
-  col_r = _lp_add_cols(ats->prob, 1);
+  col_r = _lp_add_cols (ats->prob, 1);
 
-  _lp_set_col_name(ats->prob, col_r, "r");
-  _lp_set_obj_coef(ats->prob, col_r, ats->R);
-  _lp_set_col_bnds(ats->prob, col_r, GLP_LO, 0.0, 0.0);
-  _lp_add_rows(ats->prob, c_p);
+  _lp_set_col_name (ats->prob, col_r, "r");
+  _lp_set_obj_coef (ats->prob, col_r, ats->R);
+  _lp_set_col_bnds (ats->prob, col_r, GLP_LO, 0.0, 0.0);
+  _lp_add_rows (ats->prob, c_p);
 
   stat->col_r = col_r;
-  for (c=1; c<=c_p; c++)
+  for (c = 1; c <= c_p; c++)
   {
-    _lp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
+    _lp_set_row_bnds (ats->prob, row_index, GLP_LO, 0.0, 0.0);
     struct ATS_mechanism *m = peers[c].m_head;
-    while (m!=NULL)
+
+    while (m != NULL)
     {
       ia[array_index] = row_index;
       ja[array_index] = m->col_index;
       ar[array_index] = 1 / mechanisms[c].peer->f;
 #if VERBOSE_ATS
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-          array_index,
-          ia[array_index],
-          ja[array_index],
-          ar[array_index]);
+                  array_index,
+                  ia[array_index], ja[array_index], ar[array_index]);
 #endif
       array_index++;
       m = m->next;
@@ -979,17 +981,14 @@ int ats_create_problem (struct ATS_Handle *ats,
     ar[array_index] = -1;
 #if VERBOSE_ATS
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-        array_index,
-        ia[array_index],
-        ja[array_index],
-        ar[array_index]);
+                array_index, ia[array_index], ja[array_index], ar[array_index]);
 #endif
     array_index++;
     row_index++;
   }
 
   /* Loading the matrix */
-  _lp_load_matrix(ats->prob, array_index-1, ia, ja, ar);
+  _lp_load_matrix (ats->prob, array_index - 1, ia, ja, ar);
 
   stat->c_mechs = c_m;
   stat->c_peers = c_p;
@@ -1005,30 +1004,31 @@ int ats_create_problem (struct ATS_Handle *ats,
 }
 
 
-void ats_delete_problem (struct ATS_Handle * ats)
+void
+ats_delete_problem (struct ATS_Handle *ats)
 {
 #if DEBUG_ATS
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Deleting problem\n");
 #endif
   int c;
 
-  for (c=0; c< (ats->internal).c_mechs; c++)
-          GNUNET_free_non_null (ats->mechanisms[c].rc);
-  if (ats->mechanisms!=NULL)
+  for (c = 0; c < (ats->internal).c_mechs; c++)
+    GNUNET_free_non_null (ats->mechanisms[c].rc);
+  if (ats->mechanisms != NULL)
   {
-    GNUNET_free(ats->mechanisms);
+    GNUNET_free (ats->mechanisms);
     ats->mechanisms = NULL;
   }
 
-  if (ats->peers!=NULL)
+  if (ats->peers != NULL)
   {
-    GNUNET_free(ats->peers);
+    GNUNET_free (ats->peers);
     ats->peers = NULL;
   }
 
   if (ats->prob != NULL)
   {
-    _lp_delete_prob(ats->prob);
+    _lp_delete_prob (ats->prob);
     ats->prob = NULL;
   }
 
@@ -1042,13 +1042,14 @@ void ats_delete_problem (struct ATS_Handle * ats)
   ats->internal.valid = GNUNET_SYSERR;
 }
 
-void ats_modify_problem_state (struct ATS_Handle * ats, enum ATS_problem_state s)
+void
+ats_modify_problem_state (struct ATS_Handle *ats, enum ATS_problem_state s)
 {
   if (ats == NULL)
     return;
   switch (s)
   {
-  case ATS_NEW :
+  case ATS_NEW:
     ats->internal.recreate_problem = GNUNET_NO;
     ats->internal.modified_quality = GNUNET_NO;
     ats->internal.modified_resources = GNUNET_NO;
@@ -1056,10 +1057,10 @@ void ats_modify_problem_state (struct ATS_Handle * ats, enum ATS_problem_state s
   case ATS_MODIFIED:
     ats->internal.recreate_problem = GNUNET_YES;
     break;
-  case ATS_QUALITY_UPDATED :
+  case ATS_QUALITY_UPDATED:
     ats->internal.modified_quality = GNUNET_YES;
     break;
-  case ATS_COST_UPDATED :
+  case ATS_COST_UPDATED:
     ats->internal.modified_resources = GNUNET_YES;
     break;
   case ATS_QUALITY_COST_UPDATED:
@@ -1074,12 +1075,12 @@ void ats_modify_problem_state (struct ATS_Handle * ats, enum ATS_problem_state s
 
 }
 
-void ats_solve_problem (struct ATS_Handle * ats,
-    unsigned int max_it,
-    unsigned int  max_dur,
-    unsigned int c_peers,
-    unsigned int  c_mechs,
-    struct ATS_internals *stat)
+void
+ats_solve_problem (struct ATS_Handle *ats,
+                   unsigned int max_it,
+                   unsigned int max_dur,
+                   unsigned int c_peers,
+                   unsigned int c_mechs, struct ATS_internals *stat)
 {
   int result = GNUNET_SYSERR;
   int lp_solution = GNUNET_SYSERR;
@@ -1088,7 +1089,8 @@ void ats_solve_problem (struct ATS_Handle * ats,
   // Solving simplex
 
   glp_smcp opt_lp;
-  _lp_init_smcp(&opt_lp);
+
+  _lp_init_smcp (&opt_lp);
 #if VERBOSE_ATS
   opt_lp.msg_lev = GLP_MSG_ALL;
 #else
@@ -1100,20 +1102,20 @@ void ats_solve_problem (struct ATS_Handle * ats,
   opt_lp.tm_lim = max_dur;
 
   if (ats->internal.recreate_problem == GNUNET_YES)
-     opt_lp.presolve = GLP_ON;
+    opt_lp.presolve = GLP_ON;
 
-  result = _lp_simplex(ats->prob, &opt_lp);
-  lp_solution =  _lp_get_status (ats->prob);
+  result = _lp_simplex (ats->prob, &opt_lp);
+  lp_solution = _lp_get_status (ats->prob);
 
   if ((result == GLP_ETMLIM) || (result == GLP_EITLIM))
   {
     ats->internal.valid = GNUNET_NO;
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-        "ATS exceeded time or iteration limit!\n");
+                "ATS exceeded time or iteration limit!\n");
     return;
   }
 
-  if (ats_evaluate_results(result, lp_solution, "LP") == GNUNET_YES)
+  if (ats_evaluate_results (result, lp_solution, "LP") == GNUNET_YES)
   {
     stat->valid = GNUNET_YES;
   }
@@ -1121,36 +1123,37 @@ void ats_solve_problem (struct ATS_Handle * ats,
   {
     ats->internal.simplex_rerun_required = GNUNET_YES;
     opt_lp.presolve = GLP_ON;
-    result = _lp_simplex(ats->prob, &opt_lp);
-    lp_solution =  _lp_get_status (ats->prob);
+    result = _lp_simplex (ats->prob, &opt_lp);
+    lp_solution = _lp_get_status (ats->prob);
 
     // TODO: Remove if this does not appear until release
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, ""
-        "EXECUTED SIMPLEX WITH PRESOLVER! %i \n",
-        lp_solution);
+                "EXECUTED SIMPLEX WITH PRESOLVER! %i \n", lp_solution);
 
-    if (ats_evaluate_results(result, lp_solution, "LP") != GNUNET_YES)
+    if (ats_evaluate_results (result, lp_solution, "LP") != GNUNET_YES)
     {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-            "After execution simplex with presolver: STILL INVALID!\n");
-        char * filename;
-        GNUNET_asprintf (&filename,
-            "ats_mlp_p%i_m%i_%llu.mlp",
-            ats->internal.c_peers,
-            ats->internal.c_mechs,
-            GNUNET_TIME_absolute_get().abs_value);
-        _lp_write_lp ((void *)ats->prob, NULL, filename);
-        GNUNET_free (filename);
-        stat->valid = GNUNET_NO;
-        ats->internal.recreate_problem = GNUNET_YES;
-        return;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "After execution simplex with presolver: STILL INVALID!\n");
+      char *filename;
+
+      GNUNET_asprintf (&filename,
+                       "ats_mlp_p%i_m%i_%llu.mlp",
+                       ats->internal.c_peers,
+                       ats->internal.c_mechs,
+                       GNUNET_TIME_absolute_get ().abs_value);
+      _lp_write_lp ((void *) ats->prob, NULL, filename);
+      GNUNET_free (filename);
+      stat->valid = GNUNET_NO;
+      ats->internal.recreate_problem = GNUNET_YES;
+      return;
     }
     stat->valid = GNUNET_YES;
   }
 
   // Solving mlp
   glp_iocp opt_mlp;
-  _lp_init_iocp(&opt_mlp);
+
+  _lp_init_iocp (&opt_mlp);
   // maximum duration
   opt_mlp.tm_lim = max_dur;
   // output level
@@ -1161,342 +1164,351 @@ void ats_solve_problem (struct ATS_Handle * ats,
 #endif
 
   result = _lp_intopt (ats->prob, &opt_mlp);
-  mlp_solution =  _lp_mip_status (ats->prob);
+  mlp_solution = _lp_mip_status (ats->prob);
   stat->solution = mlp_solution;
 
-  if (ats_evaluate_results(result, mlp_solution, "MLP") == GNUNET_YES)
+  if (ats_evaluate_results (result, mlp_solution, "MLP") == GNUNET_YES)
   {
-      stat->valid = GNUNET_YES;
+    stat->valid = GNUNET_YES;
   }
   else
   {
-      // TODO: Remove if this does not appear until release
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-          "MLP solution for %i peers, %i mechs is invalid: %i\n",
-          ats->internal.c_peers,
-          ats->internal.c_mechs,
-          mlp_solution);
-      stat->valid = GNUNET_NO;
+    // TODO: Remove if this does not appear until release
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "MLP solution for %i peers, %i mechs is invalid: %i\n",
+                ats->internal.c_peers, ats->internal.c_mechs, mlp_solution);
+    stat->valid = GNUNET_NO;
   }
 
 #if VERBOSE_ATS
-  if (_lp_get_col_prim(ats->prob,2*c_mechs+1) != 1)
-  {
-  int c;
-  for (c=1; c<= available_quality_metrics; c++ )
+  if (_lp_get_col_prim (ats->prob, 2 * c_mechs + 1) != 1)
   {
+    int c;
+
+    for (c = 1; c <= available_quality_metrics; c++)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
+                  _lp_get_col_name (ats->prob, 2 * c_mechs + 3 + c),
+                  _lp_get_col_prim (ats->prob, 2 * c_mechs + 3 + c));
+    }
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
-        _lp_get_col_name(ats->prob,2*c_mechs+3+c),
-        _lp_get_col_prim(ats->prob,2*c_mechs+3+c));
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
-      _lp_get_col_name(ats->prob,2*c_mechs+1),
-      _lp_get_col_prim(ats->prob,2*c_mechs+1));
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
-      _lp_get_col_name(ats->prob,2*c_mechs+2),
-      _lp_get_col_prim(ats->prob,2*c_mechs+2));
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
-      _lp_get_col_name(ats->prob,2*c_mechs+3),
-      _lp_get_col_prim(ats->prob,2*c_mechs+3));
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "objective value:  %f\n",
-      _lp_mip_obj_val(ats->prob));
+                _lp_get_col_name (ats->prob, 2 * c_mechs + 1),
+                _lp_get_col_prim (ats->prob, 2 * c_mechs + 1));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
+                _lp_get_col_name (ats->prob, 2 * c_mechs + 2),
+                _lp_get_col_prim (ats->prob, 2 * c_mechs + 2));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
+                _lp_get_col_name (ats->prob, 2 * c_mechs + 3),
+                _lp_get_col_prim (ats->prob, 2 * c_mechs + 3));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "objective value:  %f\n",
+                _lp_mip_obj_val (ats->prob));
   }
 #endif
 }
 
 
-void ats_shutdown (struct ATS_Handle * ats)
+void
+ats_shutdown (struct ATS_Handle *ats)
 {
 #if DEBUG_ATS
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ATS shutdown\n");
 #endif
   ats_delete_problem (ats);
-  _lp_free_env();
+  _lp_free_env ();
 
   GNUNET_free (ats);
 }
 
-void ats_update_problem_qm (struct ATS_Handle * ats)
+void
+ats_update_problem_qm (struct ATS_Handle *ats)
 {
-    int array_index;
-    int row_index;
-    int c, c2;
-    int c_q_metrics = available_quality_metrics;
-
-    int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
-       available_quality_metrics) * sizeof (int));
-    double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
-       available_quality_metrics) * sizeof (double));
+  int array_index;
+  int row_index;
+  int c, c2;
+  int c_q_metrics = available_quality_metrics;
+
+  int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+                            available_quality_metrics) * sizeof (int));
+  double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+                               available_quality_metrics) * sizeof (double));
 #if DEBUG_ATS
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
 #endif
-    row_index = ats->internal.begin_qm;
+  row_index = ats->internal.begin_qm;
+
+  for (c = 1; c <= c_q_metrics; c++)
+  {
+    array_index = 1;
+    double value = 1;
 
-    for (c=1; c <= c_q_metrics; c++)
-    {
-      array_index = 1;
-      double value = 1;
-#if VERBOSE_ATS
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
-#endif
-        _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
-        for (c2=1; c2<=ats->internal.c_mechs; c2++)
-        {
-          ja[array_index] = c2;
-          GNUNET_assert (ats->mechanisms[c2].addr != NULL);
-          GNUNET_assert (ats->mechanisms[c2].peer != NULL);
-
-          if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
-          {
-              double v0 = 0, v1 = 0, v2 = 0;
-
-              v0 = ats->mechanisms[c2].quality[c-1].values[0];
-              if (v1 < 1) v0 = 0.1;
-              v1 = ats->mechanisms[c2].quality[c-1].values[1];
-              if (v1 < 1) v0 = 0.1;
-              v2 = ats->mechanisms[c2].quality[c-1].values[2];
-              if (v1 < 1) v0 = 0.1;
-              value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
-              //value = 1;
-          }
-          if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
-          {
-              double v0 = 0, v1 = 0, v2 = 0;
-              v0 = ats->mechanisms[c2].quality[c-1].values[0];
-              if (v0 < 1) v0 = 1;
-              v1 = ats->mechanisms[c2].quality[c-1].values[1];
-              if (v1 < 1) v1 = 1;
-              v2 = ats->mechanisms[c2].quality[c-1].values[2];
-              if (v2 < 1) v2 = 1;
-              value =  (v0 + 2 * v1 + 3 * v2) / 6.0;
-              if (value >= 1)
-                      value =  (double) 10 / value;
-              else
-                      value = 10;
-          }
-          ar[array_index] = (ats->mechanisms[c2].peer->f) * value;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
-              array_index,
-              qm[c-1].name,
-              row_index,
-              ja[array_index],
-              ar[array_index]);
-#endif
-          array_index++;
-        }
-      ja[array_index] = ats->internal.col_qm + c - 1;
-      ar[array_index] = -1;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
+#endif
+    _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+    for (c2 = 1; c2 <= ats->internal.c_mechs; c2++)
+    {
+      ja[array_index] = c2;
+      GNUNET_assert (ats->mechanisms[c2].addr != NULL);
+      GNUNET_assert (ats->mechanisms[c2].peer != NULL);
 
+      if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
+      {
+        double v0 = 0, v1 = 0, v2 = 0;
+
+        v0 = ats->mechanisms[c2].quality[c - 1].values[0];
+        if (v1 < 1)
+          v0 = 0.1;
+        v1 = ats->mechanisms[c2].quality[c - 1].values[1];
+        if (v1 < 1)
+          v0 = 0.1;
+        v2 = ats->mechanisms[c2].quality[c - 1].values[2];
+        if (v1 < 1)
+          v0 = 0.1;
+        value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
+        //value = 1;
+      }
+      if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
+      {
+        double v0 = 0, v1 = 0, v2 = 0;
+
+        v0 = ats->mechanisms[c2].quality[c - 1].values[0];
+        if (v0 < 1)
+          v0 = 1;
+        v1 = ats->mechanisms[c2].quality[c - 1].values[1];
+        if (v1 < 1)
+          v1 = 1;
+        v2 = ats->mechanisms[c2].quality[c - 1].values[2];
+        if (v2 < 1)
+          v2 = 1;
+        value = (v0 + 2 * v1 + 3 * v2) / 6.0;
+        if (value >= 1)
+          value = (double) 10 / value;
+        else
+          value = 10;
+      }
+      ar[array_index] = (ats->mechanisms[c2].peer->f) * value;
 #if VERBOSE_ATS
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-            array_index,
-            row_index,
-            ja[array_index],
-            ar[array_index]);
-#endif
-      _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
-      array_index = 1;
-      row_index++;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
+                  array_index,
+                  qm[c - 1].name, row_index, ja[array_index], ar[array_index]);
+#endif
+      array_index++;
     }
-    GNUNET_free_non_null (ja);
-    GNUNET_free_non_null (ar);
+    ja[array_index] = ats->internal.col_qm + c - 1;
+    ar[array_index] = -1;
+
+#if VERBOSE_ATS
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                array_index, row_index, ja[array_index], ar[array_index]);
+#endif
+    _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
+    array_index = 1;
+    row_index++;
+  }
+  GNUNET_free_non_null (ja);
+  GNUNET_free_non_null (ar);
 
 }
 
 
 void
-ats_calculate_bandwidth_distribution (struct ATS_Handle * ats)
+ats_calculate_bandwidth_distribution (struct ATS_Handle *ats)
 {
-    struct GNUNET_TIME_Absolute start;
-    struct GNUNET_TIME_Relative creation;
-    struct GNUNET_TIME_Relative solving;
-    int c_m;
-    int c_p;
-    char *text = "unmodified";
+  struct GNUNET_TIME_Absolute start;
+  struct GNUNET_TIME_Relative creation;
+  struct GNUNET_TIME_Relative solving;
+  int c_m;
+  int c_p;
+  char *text = "unmodified";
 
 #if FIXME_WACHS
-    int dur;
-    if (INT_MAX < ats->max_exec_duration.rel_value)
-            dur = INT_MAX;
-    else
-            dur = (int) ats->max_exec_duration.rel_value;
+  int dur;
+
+  if (INT_MAX < ats->max_exec_duration.rel_value)
+    dur = INT_MAX;
+  else
+    dur = (int) ats->max_exec_duration.rel_value;
 #endif
 
-    ats->internal.simplex_rerun_required = GNUNET_NO;
-    start = GNUNET_TIME_absolute_get();
-    if ((ats->internal.recreate_problem == GNUNET_YES) ||
-        (ats->prob==NULL) ||
-        (ats->internal.valid == GNUNET_NO))
-    {
-      text = "new";
-      ats->internal.recreate_problem = GNUNET_YES;
-      ats_delete_problem (ats);
-      ats->addr_notification(&ats->peers , &c_p, &ats->mechanisms, &c_m);
+  ats->internal.simplex_rerun_required = GNUNET_NO;
+  start = GNUNET_TIME_absolute_get ();
+  if ((ats->internal.recreate_problem == GNUNET_YES) ||
+      (ats->prob == NULL) || (ats->internal.valid == GNUNET_NO))
+  {
+    text = "new";
+    ats->internal.recreate_problem = GNUNET_YES;
+    ats_delete_problem (ats);
+    ats->addr_notification (&ats->peers, &c_p, &ats->mechanisms, &c_m);
 #if DEBUG_ATS
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-          "Service returned: %i peer, %i mechs\n",
-          c_p,
-          c_m);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Service returned: %i peer, %i mechs\n", c_p, c_m);
 #endif
-      ats_create_problem (ats, &ats->internal, ats->peers, c_p, ats->mechanisms, c_m);
+    ats_create_problem (ats, &ats->internal, ats->peers, c_p, ats->mechanisms,
+                        c_m);
 
 
 #if DEBUG_ATS
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-          "Peers/Addresses were modified... new problem: %i peer, %i mechs\n",
-          ats->internal.c_peers,
-          ats->internal.c_mechs);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Peers/Addresses were modified... new problem: %i peer, %i mechs\n",
+                ats->internal.c_peers, ats->internal.c_mechs);
 #endif
-    }
+  }
 
-    else if ((ats->internal.recreate_problem == GNUNET_NO) &&
-        (ats->internal.modified_resources == GNUNET_YES) &&
-        (ats->internal.valid == GNUNET_YES))
-    {
-      text = "modified resources";
-      ats_update_problem_cr (ats);
-    }
-    else if ((ats->internal.recreate_problem == GNUNET_NO) &&
-        (ats->internal.modified_quality == GNUNET_YES) &&
-        (ats->internal.valid == GNUNET_YES))
-    {
-      text = "modified quality";
-      ats_update_problem_qm (ats);
-      //ats_update_problem_qm_TEST ();
-    }
+  else if ((ats->internal.recreate_problem == GNUNET_NO) &&
+           (ats->internal.modified_resources == GNUNET_YES) &&
+           (ats->internal.valid == GNUNET_YES))
+  {
+    text = "modified resources";
+    ats_update_problem_cr (ats);
+  }
+  else if ((ats->internal.recreate_problem == GNUNET_NO) &&
+           (ats->internal.modified_quality == GNUNET_YES) &&
+           (ats->internal.valid == GNUNET_YES))
+  {
+    text = "modified quality";
+    ats_update_problem_qm (ats);
+    //ats_update_problem_qm_TEST ();
+  }
 #if DEBUG_ATS
-    else GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem is %s\n", text);
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem is %s\n", text);
 #endif
 
-    creation = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
-    start = GNUNET_TIME_absolute_get();
+  creation =
+      GNUNET_TIME_absolute_get_difference (start, GNUNET_TIME_absolute_get ());
+  start = GNUNET_TIME_absolute_get ();
 
-    ats->internal.solution = GLP_UNDEF;
-    if (ats->internal.valid == GNUNET_YES)
-    {
-      ats_solve_problem(ats,
-          ats->max_iterations,
-          ats->max_exec_duration.rel_value,
-          ats->internal.c_peers,
-          ats->internal.c_mechs,
-          &ats->internal);
-    }
-    solving = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
+  ats->internal.solution = GLP_UNDEF;
+  if (ats->internal.valid == GNUNET_YES)
+  {
+    ats_solve_problem (ats,
+                       ats->max_iterations,
+                       ats->max_exec_duration.rel_value,
+                       ats->internal.c_peers,
+                       ats->internal.c_mechs, &ats->internal);
+  }
+  solving =
+      GNUNET_TIME_absolute_get_difference (start, GNUNET_TIME_absolute_get ());
 
-    if (ats->internal.valid == GNUNET_YES)
-    {
-      /* Telling about new distribution*/
-      ats->result_cb ();
+  if (ats->internal.valid == GNUNET_YES)
+  {
+    /* Telling about new distribution */
+    ats->result_cb ();
+
+    int msg_type = GNUNET_ERROR_TYPE_DEBUG;
 
-      int msg_type = GNUNET_ERROR_TYPE_DEBUG;
 #if DEBUG_ATS
-      msg_type = GNUNET_ERROR_TYPE_ERROR;
-#endif
-      GNUNET_log (msg_type,
-          "MLP %s: creation time: %llu, execution time: %llu, %i peers, %i mechanisms, simplex rerun: %s, solution %s\n",
-          text,
-          creation.rel_value,
-          solving.rel_value,
-          ats->internal.c_peers,
-          ats->internal.c_mechs,
-          (ats->internal.simplex_rerun_required == GNUNET_NO) ? "NO" : "YES",
-          (ats->internal.solution == 5) ? "OPTIMAL" : "INVALID");
-      ats->successful_executions ++;
+    msg_type = GNUNET_ERROR_TYPE_ERROR;
+#endif
+    GNUNET_log (msg_type,
+                "MLP %s: creation time: %llu, execution time: %llu, %i peers, %i mechanisms, simplex rerun: %s, solution %s\n",
+                text,
+                creation.rel_value,
+                solving.rel_value,
+                ats->internal.c_peers,
+                ats->internal.c_mechs,
+                (ats->internal.simplex_rerun_required ==
+                 GNUNET_NO) ? "NO" : "YES",
+                (ats->internal.solution == 5) ? "OPTIMAL" : "INVALID");
+    ats->successful_executions++;
+    GNUNET_STATISTICS_set (ats->stats, "# ATS successful executions",
+                           ats->successful_executions, GNUNET_NO);
+
+    if ((ats->internal.recreate_problem == GNUNET_YES) || (ats->prob == NULL))
+      GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_NEW, GNUNET_NO);
+    else if ((ats->internal.modified_resources == GNUNET_YES) &&
+             (ats->internal.modified_quality == GNUNET_NO))
+      GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_COST_UPDATED,
+                             GNUNET_NO);
+    else if ((ats->internal.modified_resources == GNUNET_NO) &&
+             (ats->internal.modified_quality == GNUNET_YES) &&
+             (ats->internal.simplex_rerun_required == GNUNET_NO))
+      GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_UPDATED,
+                             GNUNET_NO);
+    else if ((ats->internal.modified_resources == GNUNET_YES) &&
+             (ats->internal.modified_quality == GNUNET_YES) &&
+             (ats->internal.simplex_rerun_required == GNUNET_NO))
+      GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_COST_UPDATED,
+                             GNUNET_NO);
+    else if (ats->internal.simplex_rerun_required == GNUNET_NO)
+      GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_UNMODIFIED,
+                             GNUNET_NO);
+  }
+  else
+  {
+    if (ats->internal.c_peers != 0)
+    {
+      ats->invalid_executions++;
+      GNUNET_STATISTICS_set (ats->stats, "# ATS invalid executions",
+                             ats->invalid_executions, GNUNET_NO);
+    }
+    else
+    {
       GNUNET_STATISTICS_set (ats->stats, "# ATS successful executions",
-          ats->successful_executions,
-          GNUNET_NO);
-
-      if ((ats->internal.recreate_problem == GNUNET_YES) || (ats->prob==NULL))
-          GNUNET_STATISTICS_set (ats->stats, "ATS state",ATS_NEW, GNUNET_NO);
-      else if ((ats->internal.modified_resources == GNUNET_YES) &&
-              (ats->internal.modified_quality == GNUNET_NO))
-        GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_COST_UPDATED, GNUNET_NO);
-      else if ((ats->internal.modified_resources == GNUNET_NO) &&
-              (ats->internal.modified_quality == GNUNET_YES) &&
-              (ats->internal.simplex_rerun_required == GNUNET_NO))
-        GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_UPDATED, GNUNET_NO);
-      else if ((ats->internal.modified_resources == GNUNET_YES) &&
-              (ats->internal.modified_quality == GNUNET_YES) &&
-              (ats->internal.simplex_rerun_required == GNUNET_NO))
-        GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_COST_UPDATED, GNUNET_NO);
-      else if (ats->internal.simplex_rerun_required == GNUNET_NO)
-        GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_UNMODIFIED, GNUNET_NO);
+                             ats->successful_executions, GNUNET_NO);
+    }
+  }
+
+  GNUNET_STATISTICS_set (ats->stats,
+                         "ATS duration", solving.rel_value + creation.rel_value,
+                         GNUNET_NO);
+  GNUNET_STATISTICS_set (ats->stats, "ATS mechanisms", ats->internal.c_mechs,
+                         GNUNET_NO);
+  GNUNET_STATISTICS_set (ats->stats, "ATS peers", ats->internal.c_peers,
+                         GNUNET_NO);
+  GNUNET_STATISTICS_set (ats->stats, "ATS solution", ats->internal.solution,
+                         GNUNET_NO);
+  GNUNET_STATISTICS_set (ats->stats, "ATS timestamp", start.abs_value,
+                         GNUNET_NO);
+
+  if ((ats->save_mlp == GNUNET_YES) &&
+      (ats->internal.c_mechs >= ats->dump_min_peers) &&
+      (ats->internal.c_mechs >= ats->dump_min_addr))
+  {
+    char *filename;
+
+    if (ats->dump_overwrite == GNUNET_NO)
+    {
+      GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.mlp",
+                       ats->internal.c_peers,
+                       ats->internal.c_mechs,
+                       text, GNUNET_TIME_absolute_get ().abs_value);
+      _lp_write_lp ((void *) ats->prob, NULL, filename);
     }
     else
     {
-      if (ats->internal.c_peers != 0)
-      {
-        ats->invalid_executions ++;
-        GNUNET_STATISTICS_set (ats->stats, "# ATS invalid executions",
-            ats->invalid_executions, GNUNET_NO);
-      }
-      else
-      {
-        GNUNET_STATISTICS_set (ats->stats, "# ATS successful executions",
-            ats->successful_executions, GNUNET_NO);
-      }
+      GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.mlp",
+                       ats->internal.c_peers, ats->internal.c_mechs);
+      _lp_write_lp ((void *) ats->prob, NULL, filename);
     }
+    GNUNET_free (filename);
+  }
+  if ((ats->save_solution == GNUNET_YES) &&
+      (ats->internal.c_mechs >= ats->dump_min_peers) &&
+      (ats->internal.c_mechs >= ats->dump_min_addr))
+  {
+    char *filename;
 
-    GNUNET_STATISTICS_set (ats->stats,
-        "ATS duration", solving.rel_value + creation.rel_value, GNUNET_NO);
-    GNUNET_STATISTICS_set (ats->stats,
-        "ATS mechanisms", ats->internal.c_mechs, GNUNET_NO);
-    GNUNET_STATISTICS_set (ats->stats,
-        "ATS peers", ats->internal.c_peers, GNUNET_NO);
-    GNUNET_STATISTICS_set (ats->stats,
-        "ATS solution", ats->internal.solution, GNUNET_NO);
-    GNUNET_STATISTICS_set (ats->stats,
-        "ATS timestamp", start.abs_value, GNUNET_NO);
-
-    if ((ats->save_mlp == GNUNET_YES) &&
-        (ats->internal.c_mechs >= ats->dump_min_peers) &&
-        (ats->internal.c_mechs >= ats->dump_min_addr))
+    if (ats->dump_overwrite == GNUNET_NO)
     {
-        char * filename;
-        if (ats->dump_overwrite == GNUNET_NO)
-        {
-          GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.mlp",
-              ats->internal.c_peers,
-              ats->internal.c_mechs,
-              text,
-              GNUNET_TIME_absolute_get().abs_value);
-          _lp_write_lp ((void *) ats->prob, NULL, filename);
-        }
-        else
-        {
-          GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.mlp",
-          ats->internal.c_peers, ats->internal.c_mechs );
-          _lp_write_lp ((void *) ats->prob, NULL, filename);
-        }
-        GNUNET_free (filename);
+      GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.sol",
+                       ats->internal.c_peers,
+                       ats->internal.c_mechs,
+                       text, GNUNET_TIME_absolute_get ().abs_value);
+      _lp_print_sol (ats->prob, filename);
     }
-    if ((ats->save_solution == GNUNET_YES) &&
-        (ats->internal.c_mechs >= ats->dump_min_peers) &&
-        (ats->internal.c_mechs >= ats->dump_min_addr))
+    else
     {
-        char * filename;
-        if (ats->dump_overwrite == GNUNET_NO)
-        {
-          GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.sol",
-              ats->internal.c_peers,
-              ats->internal.c_mechs,
-              text,
-              GNUNET_TIME_absolute_get().abs_value);
-          _lp_print_sol (ats->prob, filename);
-        }
-        else
-        {
-          GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.sol",
-          ats->internal.c_peers, ats->internal.c_mechs);
-          _lp_print_sol (ats->prob, filename);
-        }
-        GNUNET_free (filename);
+      GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.sol",
+                       ats->internal.c_peers, ats->internal.c_mechs);
+      _lp_print_sol (ats->prob, filename);
     }
+    GNUNET_free (filename);
+  }
 
-    ats->internal.recreate_problem = GNUNET_NO;
-    ats->internal.modified_resources = GNUNET_NO;
-    ats->internal.modified_quality = GNUNET_NO;
+  ats->internal.recreate_problem = GNUNET_NO;
+  ats->internal.modified_resources = GNUNET_NO;
+  ats->internal.modified_quality = GNUNET_NO;
 }
 
 /**
@@ -1508,198 +1520,188 @@ ats_calculate_bandwidth_distribution (struct ATS_Handle * ats)
  *      valid
  */
 
-int ats_evaluate_results (int result, int solution, char * problem)
+int
+ats_evaluate_results (int result, int solution, char *problem)
 {
-    int cont = GNUNET_NO;
+  int cont = GNUNET_NO;
+
 #if DEBUG_ATS || VERBOSE_ATS
-    int error_kind = GNUNET_ERROR_TYPE_DEBUG;
+  int error_kind = GNUNET_ERROR_TYPE_DEBUG;
 #endif
 #if VERBOSE_ATS
-    error_kind = GNUNET_ERROR_TYPE_ERROR;
+  error_kind = GNUNET_ERROR_TYPE_ERROR;
 #endif
-    switch (result) {
-    case GNUNET_SYSERR : /* GNUNET problem, not GLPK related */
+  switch (result)
+  {
+  case GNUNET_SYSERR:          /* GNUNET problem, not GLPK related */
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s, GLPK solving not executed\n", problem);
+    GNUNET_log (error_kind, "%s, GLPK solving not executed\n", problem);
 #endif
-         break;
-      case GLP_ESTOP  :    /* search terminated by application */
+    break;
+  case GLP_ESTOP:              /* search terminated by application */
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s , Search terminated by application\n", problem);
+    GNUNET_log (error_kind, "%s , Search terminated by application\n", problem);
 #endif
-        break;
-      case GLP_EITLIM :    /* iteration limit exceeded */
+    break;
+  case GLP_EITLIM:             /* iteration limit exceeded */
 #if DEBUG_ATS || VERBOSE_ATS
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-          "%s Iteration limit exceeded\n", problem);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "%s Iteration limit exceeded\n", problem);
 #endif
-        break;
-     case GLP_ETMLIM :    /* time limit exceeded */
+    break;
+  case GLP_ETMLIM:             /* time limit exceeded */
 #if DEBUG_ATS || VERBOSE_ATS
-       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-           "%s Time limit exceeded\n", problem);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s Time limit exceeded\n", problem);
 #endif
-       break;
-     case GLP_ENOPFS :    /* no primal feasible solution */
-     case GLP_ENODFS :    /* no dual feasible solution */
+    break;
+  case GLP_ENOPFS:             /* no primal feasible solution */
+  case GLP_ENODFS:             /* no dual feasible solution */
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s No feasible solution\n", problem);
-#endif
-        break;
-     case GLP_EBADB  :    /* invalid basis */
-     case GLP_ESING  :    /* singular matrix */
-     case GLP_ECOND  :    /* ill-conditioned matrix */
-     case GLP_EBOUND :    /* invalid bounds */
-     case GLP_EFAIL  :    /* solver failed */
-     case GLP_EOBJLL :    /* objective lower limit reached */
-     case GLP_EOBJUL :    /* objective upper limit reached */
-     case GLP_EROOT  :    /* root LP optimum not provided */
+    GNUNET_log (error_kind, "%s No feasible solution\n", problem);
+#endif
+    break;
+  case GLP_EBADB:              /* invalid basis */
+  case GLP_ESING:              /* singular matrix */
+  case GLP_ECOND:              /* ill-conditioned matrix */
+  case GLP_EBOUND:             /* invalid bounds */
+  case GLP_EFAIL:              /* solver failed */
+  case GLP_EOBJLL:             /* objective lower limit reached */
+  case GLP_EOBJUL:             /* objective upper limit reached */
+  case GLP_EROOT:              /* root LP optimum not provided */
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s Invalid Input data: %i\n",
-            problem, result);
+    GNUNET_log (error_kind, "%s Invalid Input data: %i\n", problem, result);
 #endif
-        break;
-     case 0:
+    break;
+  case 0:
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s Problem has been solved\n", problem);
+    GNUNET_log (error_kind, "%s Problem has been solved\n", problem);
 #endif
     break;
   }
 
-  switch (solution) {
-      case GLP_UNDEF:
+  switch (solution)
+  {
+  case GLP_UNDEF:
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s solution is undefined\n", problem);
+    GNUNET_log (error_kind, "%s solution is undefined\n", problem);
 #endif
-        break;
-      case GLP_OPT:
+    break;
+  case GLP_OPT:
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s solution is optimal\n", problem);
+    GNUNET_log (error_kind, "%s solution is optimal\n", problem);
 #endif
-        cont=GNUNET_YES;
-        break;
-      case GLP_FEAS:
+    cont = GNUNET_YES;
+    break;
+  case GLP_FEAS:
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind,
-            "%s solution is %s feasible, however, its optimality (or non-optimality) has not been proven\n",
-            problem, (0==strcmp(problem,"LP")?"":"integer"));
+    GNUNET_log (error_kind,
+                "%s solution is %s feasible, however, its optimality (or non-optimality) has not been proven\n",
+                problem, (0 == strcmp (problem, "LP") ? "" : "integer"));
 #endif
-        cont=GNUNET_YES;
-        break;
-      case GLP_NOFEAS:
+    cont = GNUNET_YES;
+    break;
+  case GLP_NOFEAS:
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind, "%s problem has no %sfeasible solution\n",
-            problem,  (0==strcmp(problem,"LP")?"":"integer "));
+    GNUNET_log (error_kind, "%s problem has no %sfeasible solution\n",
+                problem, (0 == strcmp (problem, "LP") ? "" : "integer "));
 #endif
-        break;
-      case GLP_INFEAS:
+    break;
+  case GLP_INFEAS:
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind, "%s problem is infeasible \n", problem);
+    GNUNET_log (error_kind, "%s problem is infeasible \n", problem);
 #endif
-        break;
-      case GLP_UNBND:
+    break;
+  case GLP_UNBND:
 #if DEBUG_ATS || VERBOSE_ATS
-        GNUNET_log (error_kind, "%s problem is unbounded \n", problem);
+    GNUNET_log (error_kind, "%s problem is unbounded \n", problem);
 #endif
-      default:
-        break;
+  default:
+    break;
   }
-return cont;
+  return cont;
 }
 
-void ats_update_problem_cr (struct ATS_Handle * ats)
+void
+ats_update_problem_cr (struct ATS_Handle *ats)
 {
-    int array_index;
-    int row_index;
-    int c, c2;
-    double ct_max, ct_min;
-
-    int *ja    = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
-        available_quality_metrics) * sizeof (int));
-    double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
-        available_quality_metrics) * sizeof (double));
-
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
-    row_index = ats->internal.begin_cr;
-    array_index = 1;
+  int array_index;
+  int row_index;
+  int c, c2;
+  double ct_max, ct_min;
 
-    for (c=0; c<available_ressources; c++)
-    {
-      ct_max = ressources[c].c_max;
-      ct_min = ressources[c].c_min;
+  int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+                            available_quality_metrics) * sizeof (int));
+  double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+                               available_quality_metrics) * sizeof (double));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
+  row_index = ats->internal.begin_cr;
+  array_index = 1;
+
+  for (c = 0; c < available_ressources; c++)
+  {
+    ct_max = ressources[c].c_max;
+    ct_min = ressources[c].c_min;
 #if VERBOSE_ATS
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
-          row_index,
-          ct_min,
-          ct_max);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
+                row_index, ct_min, ct_max);
 #endif
-      _lp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
-      for (c2=1; c2<=ats->internal.c_mechs; c2++)
-      {
-          double value = 0;
-          GNUNET_assert (ats->mechanisms[c2].addr != NULL);
-          GNUNET_assert (ats->mechanisms[c2].peer != NULL);
+    _lp_set_row_bnds (ats->prob, row_index, GLP_DB, ct_min, ct_max);
+    for (c2 = 1; c2 <= ats->internal.c_mechs; c2++)
+    {
+      double value = 0;
+
+      GNUNET_assert (ats->mechanisms[c2].addr != NULL);
+      GNUNET_assert (ats->mechanisms[c2].peer != NULL);
 
-          ja[array_index] = c2;
-          value = ats->mechanisms[c2].ressources[c].c;
-          ar[array_index] = value;
+      ja[array_index] = c2;
+      value = ats->mechanisms[c2].ressources[c].c;
+      ar[array_index] = value;
 #if VERBOSE_ATS
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
-              array_index,
-              row_index,
-              ja[array_index],
-              ar[array_index]);
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+                  array_index, row_index, ja[array_index], ar[array_index]);
 #endif
-          array_index++;
-      }
-      _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
-      row_index ++;
+      array_index++;
     }
-    GNUNET_free_non_null (ja);
-    GNUNET_free_non_null (ar);
+    _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
+    row_index++;
+  }
+  GNUNET_free_non_null (ja);
+  GNUNET_free_non_null (ar);
 
 }
 
-void ats_set_logging_options (struct ATS_Handle * ats,
-                              struct GNUNET_STATISTICS_Handle * stats,
-                              const struct GNUNET_CONFIGURATION_Handle *cfg)
+void
+ats_set_logging_options (struct ATS_Handle *ats,
+                         struct GNUNET_STATISTICS_Handle *stats,
+                         const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int minimum_addresses;
   int minimum_peers;
   int overwrite_dump;
   int log_solution;
   int log_problem;
-  unsigned long long  value;
+  unsigned long long value;
 
   if (ats == NULL)
     return;
   log_problem = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                      "transport",
-                                                      "DUMP_MLP");
+                                                      "transport", "DUMP_MLP");
   log_solution = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                       "transport",
-                                                       "DUMP_SOLUTION");
+                                                       "transport",
+                                                       "DUMP_SOLUTION");
   overwrite_dump = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                         "transport",
-                                                         "DUMP_OVERWRITE");
+                                                         "transport",
+                                                         "DUMP_OVERWRITE");
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_number(cfg,
-                                            "transport",
-                                            "DUMP_MIN_PEERS", 
-                                            &value))
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             "transport",
+                                             "DUMP_MIN_PEERS", &value))
     minimum_peers = (int) value;
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_number(cfg,
-                                            "transport",
-                                            "DUMP_MIN_ADDRS", 
-                                            &value))
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             "transport",
+                                             "DUMP_MIN_ADDRS", &value))
     minimum_addresses = (int) value;
 
 
@@ -1712,64 +1714,58 @@ void ats_set_logging_options (struct ATS_Handle * ats,
 }
 
 #if 0
-static void ats_update_problem_qm_TEST ()
+static void
+ats_update_problem_qm_TEST ()
 {
-    int row_index;
-    int c
-    int c2;
-    int c_old;
-    int changed = 0;
-
-    int old_ja[ats->internal.c_mechs + 2];
-    double old_ar[ats->internal.c_mechs + 2];
-
-    int *ja    = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
-        available_quality_metrics) * sizeof (int));
-    double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
-        available_quality_metrics) * sizeof (double));
+  int row_index;
+  int c int c2;
+  int c_old;
+  int changed = 0;
+
+  int old_ja[ats->internal.c_mechs + 2];
+  double old_ar[ats->internal.c_mechs + 2];
+
+  int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+                            available_quality_metrics) * sizeof (int));
+  double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+                               available_quality_metrics) * sizeof (double));
 #if DEBUG_ATS
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-        "Updating problem quality metrics TEST\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Updating problem quality metrics TEST\n");
 #endif
-    if (ats->internal.begin_qm >0)
-        row_index = ats->internal.begin_qm;
-    else
-        return;
-    for (c=0; c<available_quality_metrics; c++)
+  if (ats->internal.begin_qm > 0)
+    row_index = ats->internal.begin_qm;
+  else
+    return;
+  for (c = 0; c < available_quality_metrics; c++)
+  {
+    c_old = _lp_get_mat_row (ats->prob, row_index, old_ja, old_ar);
+    _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+    for (c2 = 1; c2 <= c_old; c2++)
     {
-      c_old = _lp_get_mat_row (ats->prob, row_index, old_ja, old_ar);
-      _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
-      for (c2=1; c2<=c_old; c2++)
+      ja[c2] = old_ja[c2];
+      if ((changed < 3) && (c2 > 2) && (old_ar[c2] != -1))
       {
-        ja[c2] = old_ja[c2];
-        if ((changed < 3) && (c2>2) && (old_ar[c2] != -1))
-        {
-          ar[c2] = old_ar[c2] + 5 - changed;
-          changed ++;
-        }
-        else
-          ar[c2] = old_ar[c2];
+        ar[c2] = old_ar[c2] + 5 - changed;
+        changed++;
+      }
+      else
+        ar[c2] = old_ar[c2];
 #if VERBOSE_ATS
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-            "[index]=[%i]: old [%i,%i]=%f  new [%i,%i]=%f\n",
-            c2,
-            row_index,
-            old_ja[c2],
-            old_ar[c2],
-            row_index,
-            ja[c2],
-            ar[c2]);
-#endif
-       }
-     _lp_set_mat_row (ats->prob, row_index, c_old, ja, ar);
-     row_index ++;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "[index]=[%i]: old [%i,%i]=%f  new [%i,%i]=%f\n",
+                  c2,
+                  row_index, old_ja[c2], old_ar[c2], row_index, ja[c2], ar[c2]);
+#endif
     }
-    GNUNET_free_non_null (ja);
-    GNUNET_free_non_null (ar);
+    _lp_set_mat_row (ats->prob, row_index, c_old, ja, ar);
+    row_index++;
+  }
+  GNUNET_free_non_null (ja);
+  GNUNET_free_non_null (ar);
 }
 #endif
 
 
 
 /* end of transport_ats.c */
-
diff --git a/src/transport/gnunet-service-transport_ats.h b/src/transport/gnunet-service-transport_ats.h
index 5226c24df..d1d789b5f 100644
--- a/src/transport/gnunet-service-transport_ats.h
+++ b/src/transport/gnunet-service-transport_ats.h
@@ -68,10 +68,8 @@ struct ATS_mechanism;
 struct ATS_peer;
 
 typedef void (*GNUNET_TRANSPORT_ATS_AddressNotification)
-             (struct ATS_peer **peers,
-              int * c_p,
-              struct ATS_mechanism ** mechanisms,
-              int * c_m );
+    (struct ATS_peer ** peers,
+     int *c_p, struct ATS_mechanism ** mechanisms, int *c_m);
 
 typedef void (*GNUNET_TRANSPORT_ATS_ResultCallback) (void);
 
@@ -119,192 +117,192 @@ struct ATS_internals
      * result of last GLPK run
      * 5 == OPTIMAL
      */
-    int solution;
+  int solution;
 
     /**
      * Ressource costs or quality metrics changed
      * update problem before solving
      */
-    int modified_resources;
+  int modified_resources;
 
     /**
      * Ressource costs or quality metrics changed, update matrix
      * update problem before solving
      */
-    int modified_quality;
+  int modified_quality;
 
     /**
      * Peers have connected or disconnected
      * problem has to be recreated
      */
-    int recreate_problem;
+  int recreate_problem;
 
     /**
      * Was the available basis invalid and we needed to rerun simplex?
      */
-    int simplex_rerun_required;
+  int simplex_rerun_required;
 
     /**
      * is problem currently valid and can it be solved
      */
-    int valid;
+  int valid;
 
     /**
      * Number of transport mechanisms in the problem
      */
-    int c_mechs;
+  int c_mechs;
 
     /**
      * Number of transport mechanisms in the problem
      */
-    int c_peers;
+  int c_peers;
 
     /**
      * row index where quality related rows start
      */
-    int begin_qm;
+  int begin_qm;
 
     /**
      * row index where quality related rows end
      */
-    int end_qm;
+  int end_qm;
 
     /**
      * row index where ressource cost related rows start
      */
-    int begin_cr;
+  int begin_cr;
 
     /**
      * row index where ressource cost related rows end
      */
-    int end_cr;
+  int end_cr;
 
     /**
      * column index for objective function value d
      */
-    int col_d;
+  int col_d;
 
     /**
      * column index for objective function value u
      */
-    int col_u;
+  int col_u;
 
     /**
      * column index for objective function value r
      */
-    int col_r;
+  int col_r;
 
     /**
      * column index for objective function value quality metrics
      */
-    int col_qm;
+  int col_qm;
 
     /**
      * column index for objective function value cost ressources
      */
-    int col_cr;
+  int col_cr;
 };
 
 struct ATS_Handle
 {
-    /*
-     *  Callback functions
-     */
+  /*
+   *  Callback functions
+   */
 
-    GNUNET_TRANSPORT_ATS_AddressNotification addr_notification;
+  GNUNET_TRANSPORT_ATS_AddressNotification addr_notification;
 
-    GNUNET_TRANSPORT_ATS_ResultCallback result_cb;
+  GNUNET_TRANSPORT_ATS_ResultCallback result_cb;
 
 
     /**
      * Statistics handle
      */
-    struct GNUNET_STATISTICS_Handle *stats;
+  struct GNUNET_STATISTICS_Handle *stats;
 
     /**
      * Maximum execution time per calculation
      */
-    struct GNUNET_TIME_Relative max_exec_duration;
+  struct GNUNET_TIME_Relative max_exec_duration;
 
     /**
      * GLPK (MLP) problem object
      */
 #if HAVE_LIBGLPK
 
-    glp_prob *prob;
+  glp_prob *prob;
 #else
-    void * prob;
+  void *prob;
 #endif
 
     /**
      * Internal information state of the GLPK problem
      */
-    struct ATS_internals internal;
+  struct ATS_internals internal;
 
     /**
      * mechanisms used in current problem
      * needed for problem modification
      */
-    struct ATS_mechanism * mechanisms;
+  struct ATS_mechanism *mechanisms;
 
     /**
      * peers used in current problem
      * needed for problem modification
      */
-    struct ATS_peer * peers;
+  struct ATS_peer *peers;
 
     /**
      * State of the MLP problem
      * value of ATS_problem_state
      *
      */
-    int state;
+  int state;
 
     /**
      * number of successful executions
      */
-    int successful_executions;
+  int successful_executions;
 
     /**
      * number with an invalid result
      */
-    int invalid_executions;
+  int invalid_executions;
 
     /**
      * Maximum number of LP iterations per calculation
      */
-    int max_iterations;
+  int max_iterations;
 
 
-    /*
-     * ATS configuration
-     */
+  /*
+   * ATS configuration
+   */
 
 
     /**
      * Diversity weight
      */
-    double D;
+  double D;
 
     /**
      * Utility weight
      */
-    double U;
+  double U;
 
     /**
      * Relativity weight
      */
-    double R;
+  double R;
 
     /**
      * Minimum bandwidth per peer
      */
-    int v_b_min;
+  int v_b_min;
 
     /**
      * Minimum number of connections per peer
      */
-    int v_n_min;
+  int v_n_min;
 
 
     /**
@@ -315,104 +313,104 @@ struct ATS_Handle
     /**
      * Dump problem to a file?
      */
-    int save_mlp;
+  int save_mlp;
 
     /**
      * Dump solution to a file
      */
-    int save_solution;
+  int save_solution;
 
     /**
      * Dump solution when minimum peers:
      */
-    int dump_min_peers;
+  int dump_min_peers;
 
     /**
      * Dump solution when minimum addresses:
      */
-    int dump_min_addr;
+  int dump_min_addr;
 
     /**
      * Dump solution overwrite file:
      */
-    int dump_overwrite;
+  int dump_overwrite;
 };
 
 struct ATS_mechanism
 {
-    struct ATS_mechanism * prev;
-    struct ATS_mechanism * next;
-    struct ForeignAddressList * addr;
-    struct ATS_quality_entry * quality;
-    struct ATS_ressource_entry * ressources;
-    struct TransportPlugin * plugin;
-    struct ATS_peer * peer;
-    int col_index;
-    int     id;
-    struct ATS_ressource_cost * rc;
+  struct ATS_mechanism *prev;
+  struct ATS_mechanism *next;
+  struct ForeignAddressList *addr;
+  struct ATS_quality_entry *quality;
+  struct ATS_ressource_entry *ressources;
+  struct TransportPlugin *plugin;
+  struct ATS_peer *peer;
+  int col_index;
+  int id;
+  struct ATS_ressource_cost *rc;
 };
 
 struct ATS_peer
 {
-    struct GNUNET_PeerIdentity peer;
+  struct GNUNET_PeerIdentity peer;
 
-    struct ATS_mechanism * m_head;
-    struct ATS_mechanism * m_tail;
+  struct ATS_mechanism *m_head;
+  struct ATS_mechanism *m_tail;
 
-    /* preference value f */
-    double f;
+  /* preference value f */
+  double f;
 
-    //struct NeighbourList * n;
+  //struct NeighbourList * n;
 };
 
 struct ATS_ressource
 {
-    /* index in ressources array */
-    int index;
-    /* depending ATSi parameter to calculcate limits */
-    int atis_index;
-    /* cfg option to load limits */
-    char * cfg_param;
-    /* lower bound */
-    double c_min;
-    /* upper bound */
-    double c_max;
-
-    /* cofficients for the specific plugins */
-    double c_unix;
-    double c_tcp;
-    double c_udp;
-    double c_http;
-    double c_https;
-    double c_wlan;
-    double c_default;
+  /* index in ressources array */
+  int index;
+  /* depending ATSi parameter to calculcate limits */
+  int atis_index;
+  /* cfg option to load limits */
+  char *cfg_param;
+  /* lower bound */
+  double c_min;
+  /* upper bound */
+  double c_max;
+
+  /* cofficients for the specific plugins */
+  double c_unix;
+  double c_tcp;
+  double c_udp;
+  double c_http;
+  double c_https;
+  double c_wlan;
+  double c_default;
 };
 
 
 struct ATS_ressource_entry
 {
-    /* index in ressources array */
-    int index;
-    /* depending ATSi parameter to calculcate limits */
-    int atis_index;
-    /* lower bound */
-    double c;
+  /* index in ressources array */
+  int index;
+  /* depending ATSi parameter to calculcate limits */
+  int atis_index;
+  /* lower bound */
+  double c;
 };
 
 
 struct ATS_quality_metric
 {
-    int index;
-    int atis_index;
-    char * name;
+  int index;
+  int atis_index;
+  char *name;
 };
 
 struct ATS_quality_entry
 {
-    int index;
-    int atsi_index;
-    uint32_t values[3];
-    int current;
+  int index;
+  int atsi_index;
+  uint32_t values[3];
+  int current;
 };
 
 /*
@@ -420,12 +418,11 @@ struct ATS_quality_entry
  */
 
 
-static struct ATS_ressource ressources[] =
-{
-    /* FIXME: the coefficients for the specific plugins */
-    {1, 7, "LAN_BW_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 1, 1, 2, 2, 1, 3},
-    {2, 7, "WAN_BW_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 1, 1, 2, 2, 2, 3},
-    {3, 4, "WLAN_ENERGY_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 0, 0, 0, 0, 2, 1}
+static struct ATS_ressource ressources[] = {
+  /* FIXME: the coefficients for the specific plugins */
+  {1, 7, "LAN_BW_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 1, 1, 2, 2, 1, 3},
+  {2, 7, "WAN_BW_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 1, 1, 2, 2, 2, 3},
+  {3, 4, "WLAN_ENERGY_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 0, 0, 0, 0, 2, 1}
 /*
     {4, 4, "COST_ENERGY_CONSUMPTION", VERY_BIG_DOUBLE_VALUE},
     {5, 5, "COST_CONNECT", VERY_BIG_DOUBLE_VALUE},
@@ -439,8 +436,7 @@ static struct ATS_ressource ressources[] =
  * ATS quality metrics
  */
 
-static struct ATS_quality_metric qm[] =
-{
+static struct ATS_quality_metric qm[] = {
   {1, 1028, "QUALITY_NET_DISTANCE"},
   {2, 1034, "QUALITY_NET_DELAY"},
 };
@@ -451,61 +447,50 @@ static struct ATS_quality_metric qm[] =
 /*
  * ATS functions
  */
-struct ATS_Handle *
-ats_init (double D,
-          double U,
-          double R,
-          int v_b_min,
-          int v_n_min,
-          int max_iterations,
-          struct GNUNET_TIME_Relative max_duration,
-          GNUNET_TRANSPORT_ATS_AddressNotification address_not,
-          GNUNET_TRANSPORT_ATS_ResultCallback res_cb);
+struct ATS_Handle *ats_init (double D,
+                             double U,
+                             double R,
+                             int v_b_min,
+                             int v_n_min,
+                             int max_iterations,
+                             struct GNUNET_TIME_Relative max_duration,
+                             GNUNET_TRANSPORT_ATS_AddressNotification
+                             address_not,
+                             GNUNET_TRANSPORT_ATS_ResultCallback res_cb);
 
-void
-ats_shutdown (struct ATS_Handle * ats);
+void ats_shutdown (struct ATS_Handle *ats);
 
-void
-ats_delete_problem (struct ATS_Handle * ats);
+void ats_delete_problem (struct ATS_Handle *ats);
 
 int
 ats_create_problem (struct ATS_Handle *ats,
                     struct ATS_internals *stat,
                     struct ATS_peer *peers,
-                    int c_p,
-                    struct ATS_mechanism *mechanisms,
-                    int c_m);
+                    int c_p, struct ATS_mechanism *mechanisms, int c_m);
 
-void ats_modify_problem_state (struct ATS_Handle * ats,
-    enum ATS_problem_state s);
+void ats_modify_problem_state (struct ATS_Handle *ats,
+                               enum ATS_problem_state s);
 
-void
-ats_calculate_bandwidth_distribution (struct ATS_Handle * ats);
+void ats_calculate_bandwidth_distribution (struct ATS_Handle *ats);
 
 void
-ats_solve_problem (struct ATS_Handle * ats,
-    unsigned int max_it,
-    unsigned int  max_dur,
-    unsigned int c_peers,
-    unsigned int  c_mechs,
-    struct ATS_internals *stat);
+ats_solve_problem (struct ATS_Handle *ats,
+                   unsigned int max_it,
+                   unsigned int max_dur,
+                   unsigned int c_peers,
+                   unsigned int c_mechs, struct ATS_internals *stat);
 
-int
-ats_evaluate_results (int result,
-    int solution,
-    char * problem);
+int ats_evaluate_results (int result, int solution, char *problem);
 
-void
-ats_update_problem_qm (struct ATS_Handle * ats);
+void ats_update_problem_qm (struct ATS_Handle *ats);
 
-void
-ats_update_problem_cr (struct ATS_Handle * ats);
+void ats_update_problem_cr (struct ATS_Handle *ats);
 
 
 void
-ats_set_logging_options (struct ATS_Handle * ats,
-                         struct GNUNET_STATISTICS_Handle *stats,
-                         const struct GNUNET_CONFIGURATION_Handle *cfg);
+ats_set_logging_options (struct ATS_Handle *ats,
+                         struct GNUNET_STATISTICS_Handle *stats,
+                         const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 #endif
 /* end of file gnunet-service-transport_ats.h */
diff --git a/src/transport/gnunet-service-transport_blacklist.c b/src/transport/gnunet-service-transport_blacklist.c
index 4738cdc0f..7720e467f 100644
--- a/src/transport/gnunet-service-transport_blacklist.c
+++ b/src/transport/gnunet-service-transport_blacklist.c
@@ -162,8 +162,7 @@ static struct GNUNET_CONTAINER_MultiHashMap *blacklist;
  * @param tc unused
  */
 static void
-do_blacklist_check (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc);
+do_blacklist_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -174,8 +173,7 @@ do_blacklist_check (void *cls,
  * @param client identification of the client
  */
 static void
-client_disconnect_notification (void *cls,
-                                struct GNUNET_SERVER_Client *client)
+client_disconnect_notification (void *cls, struct GNUNET_SERVER_Client *client)
 {
   struct Blacklisters *bl;
   struct GST_BlacklistCheck *bc;
@@ -183,31 +181,28 @@ client_disconnect_notification (void *cls,
   if (client == NULL)
     return;
   for (bl = bl_head; bl != NULL; bl = bl->next)
+  {
+    if (bl->client != client)
+      continue;
+    for (bc = bc_head; bc != NULL; bc = bc->next)
     {
-      if (bl->client != client)
-        continue;
-      for (bc = bc_head; bc != NULL; bc = bc->next)
-        {
-          if (bc->bl_pos != bl)
-            continue;
-          bc->bl_pos = bl->next;
-          if (bc->th != NULL)
-            {
-              GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
-              bc->th = NULL;
-            }
-          if (bc->task == GNUNET_SCHEDULER_NO_TASK)
-            bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                                 bc);
-          break;
-        }
-      GNUNET_CONTAINER_DLL_remove (bl_head,
-                                   bl_tail,
-                                   bl);
-      GNUNET_SERVER_client_drop (bl->client);
-      GNUNET_free (bl);
+      if (bc->bl_pos != bl)
+        continue;
+      bc->bl_pos = bl->next;
+      if (bc->th != NULL)
+      {
+        GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
+        bc->th = NULL;
+      }
+      if (bc->task == GNUNET_SCHEDULER_NO_TASK)
+        bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
       break;
     }
+    GNUNET_CONTAINER_DLL_remove (bl_head, bl_tail, bl);
+    GNUNET_SERVER_client_drop (bl->client);
+    GNUNET_free (bl);
+    break;
+  }
 }
 
 
@@ -234,153 +229,152 @@ read_blacklist_file ()
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (GST_cfg,
                                                "TRANSPORT",
-                                               "BLACKLIST_FILE",
-                                               &fn))
-    {
+                                               "BLACKLIST_FILE", &fn))
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Option `%s' in section `%s' not specified!\n",
-                  "BLACKLIST_FILE",
-                  "TRANSPORT");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Option `%s' in section `%s' not specified!\n",
+                "BLACKLIST_FILE", "TRANSPORT");
 #endif
-      return;
-    }
+    return;
+  }
   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
-    GNUNET_DISK_fn_write (fn, NULL, 0, 
-                          GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+    GNUNET_DISK_fn_write (fn, NULL, 0,
+                          GNUNET_DISK_PERM_USER_READ |
+                          GNUNET_DISK_PERM_USER_WRITE);
   if (0 != STAT (fn, &frstat))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not read blacklist file `%s'\n"), 
-                  fn);
-      GNUNET_free (fn);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not read blacklist file `%s'\n"), fn);
+    GNUNET_free (fn);
+    return;
+  }
   if (frstat.st_size == 0)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Blacklist file `%s' is empty.\n"),
-                  fn);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Blacklist file `%s' is empty.\n"), fn);
 #endif
-      GNUNET_free (fn);
-      return;
-    }
+    GNUNET_free (fn);
+    return;
+  }
   /* FIXME: use mmap */
   data = GNUNET_malloc_large (frstat.st_size);
-  GNUNET_assert(data != NULL);
-  if (frstat.st_size !=
-      GNUNET_DISK_fn_read (fn, data, frstat.st_size))
+  GNUNET_assert (data != NULL);
+  if (frstat.st_size != GNUNET_DISK_fn_read (fn, data, frstat.st_size))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to read blacklist from `%s'\n"), fn);
+    GNUNET_free (fn);
+    GNUNET_free (data);
+    return;
+  }
+  entries_found = 0;
+  pos = 0;
+  while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))
+    pos++;
+  while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
+         (pos <=
+          frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
+  {
+    colon_pos = pos;
+    while ((colon_pos < frstat.st_size) &&
+           (data[colon_pos] != ':') &&
+           (!isspace ((unsigned char) data[colon_pos])))
+      colon_pos++;
+    if (colon_pos >= frstat.st_size)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to read blacklist from `%s'\n"), 
-                  fn);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, giving up!\n"),
+                  (unsigned long long) colon_pos);
       GNUNET_free (fn);
       GNUNET_free (data);
       return;
     }
-  entries_found = 0;
-  pos = 0;
-  while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
-    pos++;
-  while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
-         (pos <= frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
+
+    if (isspace ((unsigned char) data[colon_pos]))
     {
-      colon_pos = pos;
-      while ( (colon_pos < frstat.st_size) && 
-              (data[colon_pos] != ':') && 
-              (! isspace ( (unsigned char) data[colon_pos])) )
-        colon_pos++;
-      if (colon_pos >= frstat.st_size)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, giving up!\n"),
-                      (unsigned long long) colon_pos);
-          GNUNET_free (fn);
-          GNUNET_free (data);
-          return;
-        }
-
-      if (isspace( (unsigned char) data[colon_pos]))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
-                    (unsigned long long) colon_pos);
-        pos = colon_pos;
-        while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
-          pos++;
-        continue;
-      }
-      tsize = colon_pos - pos;
-      if ((pos >= frstat.st_size) || (pos + tsize >= frstat.st_size) || (tsize == 0))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, giving up!\n"),
-                      (unsigned long long) colon_pos);
-          GNUNET_free (fn);
-          GNUNET_free (data);
-          return;
-        }
-
-      if (tsize < 1)
-        continue;
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
+                  (unsigned long long) colon_pos);
+      pos = colon_pos;
+      while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))
+        pos++;
+      continue;
+    }
+    tsize = colon_pos - pos;
+    if ((pos >= frstat.st_size) || (pos + tsize >= frstat.st_size) ||
+        (tsize == 0))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, giving up!\n"),
+                  (unsigned long long) colon_pos);
+      GNUNET_free (fn);
+      GNUNET_free (data);
+      return;
+    }
 
-      transport_name = GNUNET_malloc(tsize + 1);
-      memcpy(transport_name, &data[pos], tsize);
-      pos = colon_pos + 1;
+    if (tsize < 1)
+      continue;
+
+    transport_name = GNUNET_malloc (tsize + 1);
+    memcpy (transport_name, &data[pos], tsize);
+    pos = colon_pos + 1;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Read transport name `%s' in blacklist file.\n",
-                  transport_name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Read transport name `%s' in blacklist file.\n",
+                transport_name);
 #endif
-      memcpy (&enc, 
-              &data[pos],
-              sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
-      if (! isspace ( (unsigned char) enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
-                      (unsigned long long) pos);
-          pos++;
-          while ((pos < frstat.st_size) && (!isspace ( (unsigned char) data[pos])))
-            pos++;
-          GNUNET_free_non_null(transport_name);
-          continue;
-        }
-      enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
-      if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Syntax error in blacklist file at offset %llu, skipping bytes `%s'.\n"),
-                      (unsigned long long) pos,
-                      &enc);
-        }
-      else
-        {
-          if (0 != memcmp (&pid,
-                           &GST_my_identity,
-                           sizeof (struct GNUNET_PeerIdentity)))
-            {
-              entries_found++;
-              GST_blacklist_add_peer (&pid,
-                                      transport_name);
-            }
-          else
-            {
-              GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                          _("Found myself `%s' in blacklist (useless, ignored)\n"),
-                          GNUNET_i2s (&pid));
-            }
-        }
-      pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
-      GNUNET_free_non_null(transport_name);
-      while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
+    memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+    if (!isspace
+        ((unsigned char)
+         enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
+                  (unsigned long long) pos);
+      pos++;
+      while ((pos < frstat.st_size) && (!isspace ((unsigned char) data[pos])))
         pos++;
+      GNUNET_free_non_null (transport_name);
+      continue;
+    }
+    enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in blacklist file at offset %llu, skipping bytes `%s'.\n"),
+                  (unsigned long long) pos, &enc);
     }
-  GNUNET_STATISTICS_update (GST_stats, 
-                            "# Transport entries blacklisted",
-                            entries_found,
-                            GNUNET_NO);
+    else
+    {
+      if (0 != memcmp (&pid,
+                       &GST_my_identity, sizeof (struct GNUNET_PeerIdentity)))
+      {
+        entries_found++;
+        GST_blacklist_add_peer (&pid, transport_name);
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _("Found myself `%s' in blacklist (useless, ignored)\n"),
+                    GNUNET_i2s (&pid));
+      }
+    }
+    pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
+    GNUNET_free_non_null (transport_name);
+    while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))
+      pos++;
+  }
+  GNUNET_STATISTICS_update (GST_stats,
+                            "# Transport entries blacklisted",
+                            entries_found, GNUNET_NO);
   GNUNET_free (data);
   GNUNET_free (fn);
 }
@@ -396,8 +390,7 @@ GST_blacklist_start (struct GNUNET_SERVER_Handle *server)
 {
   read_blacklist_file ();
   GNUNET_SERVER_disconnect_notify (server,
-                                   &client_disconnect_notification,
-                                   NULL);
+                                   &client_disconnect_notification, NULL);
 }
 
 
@@ -410,9 +403,7 @@ GST_blacklist_start (struct GNUNET_SERVER_Handle *server)
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-free_blacklist_entry (void *cls,
-                      const GNUNET_HashCode *key,
-                      void *value)
+free_blacklist_entry (void *cls, const GNUNET_HashCode * key, void *value)
 {
   char *be = value;
 
@@ -428,13 +419,12 @@ void
 GST_blacklist_stop ()
 {
   if (NULL != blacklist)
-    {
-      GNUNET_CONTAINER_multihashmap_iterate (blacklist,
-                                             &free_blacklist_entry,
-                                             NULL);
-      GNUNET_CONTAINER_multihashmap_destroy (blacklist);
-      blacklist = NULL;
-    }
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (blacklist,
+                                           &free_blacklist_entry, NULL);
+    GNUNET_CONTAINER_multihashmap_destroy (blacklist);
+    blacklist = NULL;
+  }
 }
 
 
@@ -447,9 +437,7 @@ GST_blacklist_stop ()
  * @return number of bytes copied to buf
  */
 static size_t
-transmit_blacklist_message (void *cls,
-                            size_t size,
-                            void *buf)
+transmit_blacklist_message (void *cls, size_t size, void *buf)
 {
   struct GST_BlacklistCheck *bc = cls;
   struct Blacklisters *bl;
@@ -457,19 +445,18 @@ transmit_blacklist_message (void *cls,
 
   bc->th = NULL;
   if (size == 0)
-    {
-      GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
-      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                           bc);
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Failed to send blacklist test for peer `%s' to client\n",
-                  GNUNET_i2s (&bc->peer));
-      return 0;
-    }
+  {
+    GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
+    bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to send blacklist test for peer `%s' to client\n",
+                GNUNET_i2s (&bc->peer));
+    return 0;
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending blacklist test for peer `%s' to client\n",
-              GNUNET_i2s (&bc->peer));
+              "Sending blacklist test for peer `%s' to client\n",
+              GNUNET_i2s (&bc->peer));
 #endif
   bl = bc->bl_pos;
   bm.header.size = htons (sizeof (struct BlacklistMessage));
@@ -490,8 +477,7 @@ transmit_blacklist_message (void *cls,
  * @param tc unused
  */
 static void
-do_blacklist_check (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_blacklist_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GST_BlacklistCheck *bc = cls;
   struct Blacklisters *bl;
@@ -499,27 +485,25 @@ do_blacklist_check (void *cls,
   bc->task = GNUNET_SCHEDULER_NO_TASK;
   bl = bc->bl_pos;
   if (bl == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No other blacklist clients active, will allow neighbour `%s'\n",
-                  GNUNET_i2s (&bc->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No other blacklist clients active, will allow neighbour `%s'\n",
+                GNUNET_i2s (&bc->peer));
 #endif
-      bc->cont (bc->cont_cls,
-                &bc->peer, 
-                GNUNET_OK);
-      GNUNET_free (bc);
-      return;
-    }
-  if ( (bl->bc != NULL) ||
-       (bl->waiting_for_reply != GNUNET_NO) )
-    return; /* someone else busy with this client */
+    bc->cont (bc->cont_cls, &bc->peer, GNUNET_OK);
+    GNUNET_free (bc);
+    return;
+  }
+  if ((bl->bc != NULL) || (bl->waiting_for_reply != GNUNET_NO))
+    return;                     /* someone else busy with this client */
   bl->bc = bc;
   bc->th = GNUNET_SERVER_notify_transmit_ready (bl->client,
-                                                sizeof (struct BlacklistMessage),
-                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                                &transmit_blacklist_message,
-                                                bc);    
+                                                sizeof (struct
+                                                        BlacklistMessage),
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                &transmit_blacklist_message,
+                                                bc);
 }
 
 
@@ -534,15 +518,13 @@ do_blacklist_check (void *cls,
  */
 static void
 confirm_or_drop_neighbour (void *cls,
-                           const struct GNUNET_PeerIdentity *peer,
-                           int allowed)
+                           const struct GNUNET_PeerIdentity *peer, int allowed)
 {
   if (GNUNET_OK == allowed)
-    return; /* we're done */
+    return;                     /* we're done */
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# disconnects due to blacklist"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# disconnects due to blacklist"),
+                            1, GNUNET_NO);
   GST_neighbours_force_disconnect (peer);
 }
 
@@ -554,7 +536,7 @@ struct TestConnectionContext
 {
   /**
    * Is this the first neighbour we're checking?
-   */ 
+   */
   int first;
 
   /**
@@ -575,9 +557,9 @@ struct TestConnectionContext
  */
 static void
 test_connection_ok (void *cls,
-                    const struct GNUNET_PeerIdentity *neighbour,
-                    const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                    uint32_t ats_count)
+                    const struct GNUNET_PeerIdentity *neighbour,
+                    const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                    uint32_t ats_count)
 {
   struct TestConnectionContext *tcc = cls;
   struct GST_BlacklistCheck *bc;
@@ -589,13 +571,12 @@ test_connection_ok (void *cls,
   bc->cont_cls = NULL;
   bc->bl_pos = tcc->bl;
   if (GNUNET_YES == tcc->first)
-    { 
-      /* all would wait for the same client, no need to
-         create more than just the first task right now */
-      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                           bc);
-      tcc->first = GNUNET_NO;
-    }
+  {
+    /* all would wait for the same client, no need to
+     * create more than just the first task right now */
+    bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+    tcc->first = GNUNET_NO;
+  }
 }
 
 
@@ -611,23 +592,23 @@ test_connection_ok (void *cls,
  */
 void
 GST_blacklist_handle_init (void *cls,
-                           struct GNUNET_SERVER_Client *client,
-                           const struct GNUNET_MessageHeader *message)
+                           struct GNUNET_SERVER_Client *client,
+                           const struct GNUNET_MessageHeader *message)
 {
   struct Blacklisters *bl;
   struct TestConnectionContext tcc;
 
   bl = bl_head;
   while (bl != NULL)
+  {
+    if (bl->client == client)
     {
-      if (bl->client == client)
-        {
-          GNUNET_break (0);
-          GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-          return;
-        }
-      bl = bl->next;
+      GNUNET_break (0);
+      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+      return;
     }
+    bl = bl->next;
+  }
   bl = GNUNET_malloc (sizeof (struct Blacklisters));
   bl->client = client;
   GNUNET_SERVER_client_keep (client);
@@ -636,8 +617,7 @@ GST_blacklist_handle_init (void *cls,
   /* confirm that all existing connections are OK! */
   tcc.bl = bl;
   tcc.first = GNUNET_YES;
-  GST_neighbours_iterate (&test_connection_ok,
-                          &tcc);
+  GST_neighbours_iterate (&test_connection_ok, &tcc);
 }
 
 
@@ -650,65 +630,61 @@ GST_blacklist_handle_init (void *cls,
  */
 void
 GST_blacklist_handle_reply (void *cls,
-                            struct GNUNET_SERVER_Client *client,
-                            const struct GNUNET_MessageHeader *message)
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message)
 {
-  const struct BlacklistMessage *msg = (const struct BlacklistMessage*) message;
+  const struct BlacklistMessage *msg =
+      (const struct BlacklistMessage *) message;
   struct Blacklisters *bl;
   struct GST_BlacklistCheck *bc;
 
   bl = bl_head;
-  while ( (bl != NULL) &&
-          (bl->client != client) )
+  while ((bl != NULL) && (bl->client != client))
     bl = bl->next;
   if (bl == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Blacklist client disconnected\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Blacklist client disconnected\n");
 #endif
-      /* FIXME: other error handling here!? */
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+    /* FIXME: other error handling here!? */
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   bc = bl->bc;
   bl->bc = NULL;
   bl->waiting_for_reply = GNUNET_NO;
   if (NULL != bc)
+  {
+    /* only run this if the blacklist check has not been 
+     * cancelled in the meantime... */
+    if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
     {
-      /* only run this if the blacklist check has not been 
-         cancelled in the meantime... */
-      if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
-        {
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Blacklist check failed, peer not allowed\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Blacklist check failed, peer not allowed\n");
 #endif
-          bc->cont (bc->cont_cls, &bc->peer, GNUNET_NO);
-          GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
-          GNUNET_free (bc);
-        }
-      else
-        {
+      bc->cont (bc->cont_cls, &bc->peer, GNUNET_NO);
+      GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
+      GNUNET_free (bc);
+    }
+    else
+    {
 #if DEBUG_TRANSPORT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Blacklist check succeeded, continuing with checks\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Blacklist check succeeded, continuing with checks\n");
 #endif
-          bc->bl_pos = bc->bl_pos->next;
-          bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                               bc);
-        }
+      bc->bl_pos = bc->bl_pos->next;
+      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
     }
+  }
   /* check if any other bc's are waiting for this blacklister */
   bc = bc_head;
   for (bc = bc_head; bc != NULL; bc = bc->next)
-    if ( (bc->bl_pos == bl) &&
-         (GNUNET_SCHEDULER_NO_TASK == bc->task) )
-      {
-        bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                             bc);
-        break;
-      }
+    if ((bc->bl_pos == bl) && (GNUNET_SCHEDULER_NO_TASK == bc->task))
+    {
+      bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
+      break;
+    }
 }
 
 
@@ -720,20 +696,19 @@ GST_blacklist_handle_reply (void *cls,
  */
 void
 GST_blacklist_add_peer (const struct GNUNET_PeerIdentity *peer,
-                        const char *transport_name)
+                        const char *transport_name)
 {
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding peer `%s' with plugin `%s' to blacklist\n",
-              GNUNET_i2s (peer),
-              transport_name);
+              "Adding peer `%s' with plugin `%s' to blacklist\n",
+              GNUNET_i2s (peer), transport_name);
 #endif
   if (blacklist == NULL)
-    blacklist = GNUNET_CONTAINER_multihashmap_create(TRANSPORT_BLACKLIST_HT_SIZE);
-  GNUNET_CONTAINER_multihashmap_put (blacklist,
-                                     &peer->hashPubKey,
-                                     GNUNET_strdup (transport_name),
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    blacklist =
+        GNUNET_CONTAINER_multihashmap_create (TRANSPORT_BLACKLIST_HT_SIZE);
+  GNUNET_CONTAINER_multihashmap_put (blacklist, &peer->hashPubKey,
+                                     GNUNET_strdup (transport_name),
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 }
 
 
@@ -747,16 +722,13 @@ GST_blacklist_add_peer (const struct GNUNET_PeerIdentity *peer,
  * @return GNUNET_OK if the entry does not match, GNUNET_NO if it matches
  */
 static int
-test_blacklisted (void *cls,
-                  const GNUNET_HashCode *key,
-                  void *value)
+test_blacklisted (void *cls, const GNUNET_HashCode * key, void *value)
 {
   const char *transport_name = cls;
   char *be = value;
 
-  if (0 == strcmp (transport_name,
-                   be))
-    return GNUNET_NO; /* abort iteration! */
+  if (0 == strcmp (transport_name, be))
+    return GNUNET_NO;           /* abort iteration! */
   return GNUNET_OK;
 }
 
@@ -773,36 +745,34 @@ test_blacklisted (void *cls,
  */
 struct GST_BlacklistCheck *
 GST_blacklist_test_allowed (const struct GNUNET_PeerIdentity *peer,
-                            const char *transport_name,
-                            GST_BlacklistTestContinuation cont,
-                            void *cont_cls)
+                            const char *transport_name,
+                            GST_BlacklistTestContinuation cont, void *cont_cls)
 {
   struct GST_BlacklistCheck *bc;
-  
-  if ( (blacklist != NULL) &&
-       (GNUNET_SYSERR ==
-        GNUNET_CONTAINER_multihashmap_get_multiple (blacklist,
-                                                    &peer->hashPubKey,
-                                                    &test_blacklisted,
-                                                    (void*) transport_name)) )
-    {
-      /* disallowed by config, disapprove instantly */
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# disconnects due to blacklist"),
-                                1,
-                                GNUNET_NO);
-      if (cont != NULL)
-        cont (cont_cls, peer, GNUNET_NO);
-      return NULL;
-    }
+
+  if ((blacklist != NULL) &&
+      (GNUNET_SYSERR ==
+       GNUNET_CONTAINER_multihashmap_get_multiple (blacklist,
+                                                   &peer->hashPubKey,
+                                                   &test_blacklisted,
+                                                   (void *) transport_name)))
+  {
+    /* disallowed by config, disapprove instantly */
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop ("# disconnects due to blacklist"),
+                              1, GNUNET_NO);
+    if (cont != NULL)
+      cont (cont_cls, peer, GNUNET_NO);
+    return NULL;
+  }
 
   if (bl_head == NULL)
-    {
-      /* no blacklist clients, approve instantly */
-      if (cont != NULL)
-        cont (cont_cls, peer, GNUNET_OK);
-      return NULL;
-    }
+  {
+    /* no blacklist clients, approve instantly */
+    if (cont != NULL)
+      cont (cont_cls, peer, GNUNET_OK);
+    return NULL;
+  }
 
   /* need to query blacklist clients */
   bc = GNUNET_malloc (sizeof (struct GST_BlacklistCheck));
@@ -811,11 +781,10 @@ GST_blacklist_test_allowed (const struct GNUNET_PeerIdentity *peer,
   bc->cont = cont;
   bc->cont_cls = cont_cls;
   bc->bl_pos = bl_head;
-  bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
-                                       bc);
+  bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
   return bc;
 }
-                                         
+
 
 /**
  * Cancel a blacklist check.
@@ -827,25 +796,25 @@ GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc)
 {
   GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
   if (bc->bl_pos != NULL)
+  {
+    if (bc->bl_pos->bc == bc)
     {
-      if (bc->bl_pos->bc == bc)
-        {
-          /* we're at the head of the queue, remove us! */
-          bc->bl_pos->bc = NULL;
-        }
+      /* we're at the head of the queue, remove us! */
+      bc->bl_pos->bc = NULL;
     }
+  }
   if (GNUNET_SCHEDULER_NO_TASK != bc->task)
-    {
-      GNUNET_SCHEDULER_cancel (bc->task);
-      bc->task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (bc->task);
+    bc->task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != bc->th)
-    {
-      GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
-      bc->th = NULL;
-    }
+  {
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
+    bc->th = NULL;
+  }
   GNUNET_free (bc);
-}                                        
+}
 
 
 /* end of file gnunet-service-transport_blacklist.c */
diff --git a/src/transport/gnunet-service-transport_blacklist.h b/src/transport/gnunet-service-transport_blacklist.h
index 26309818d..4823d055d 100644
--- a/src/transport/gnunet-service-transport_blacklist.h
+++ b/src/transport/gnunet-service-transport_blacklist.h
@@ -34,15 +34,13 @@
  *
  * @param server server used to accept clients from
  */
-void
-GST_blacklist_start (struct GNUNET_SERVER_Handle *server);
+void GST_blacklist_start (struct GNUNET_SERVER_Handle *server);
 
 
 /**
  * Stop blacklist subsystem.
  */
-void
-GST_blacklist_stop (void);
+void GST_blacklist_stop (void);
 
 
 /**
@@ -56,8 +54,8 @@ GST_blacklist_stop (void);
  */
 void
 GST_blacklist_handle_init (void *cls,
-                           struct GNUNET_SERVER_Client *client,
-                           const struct GNUNET_MessageHeader *message);
+                           struct GNUNET_SERVER_Client *client,
+                           const struct GNUNET_MessageHeader *message);
 
 /**
  * A blacklisting client has sent us reply. Process it.
@@ -68,8 +66,8 @@ GST_blacklist_handle_init (void *cls,
  */
 void
 GST_blacklist_handle_reply (void *cls,
-                            struct GNUNET_SERVER_Client *client,
-                            const struct GNUNET_MessageHeader *message);
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message);
 
 /**
  * Add the given peer to the blacklist (for the given transport).
@@ -79,14 +77,14 @@ GST_blacklist_handle_reply (void *cls,
  */
 void
 GST_blacklist_add_peer (const struct GNUNET_PeerIdentity *peer,
-                        const char *transport_name);
+                        const char *transport_name);
 
 
 /**
  * Handle to an active blacklist check.
  */
-struct GST_BlacklistCheck;      
-                                                
+struct GST_BlacklistCheck;
+
 
 /**
  * Continuation called from a blacklist test.
@@ -96,9 +94,9 @@ struct GST_BlacklistCheck;
  * @param result GNUNET_OK if the connection is allowed,
  *               GNUNET_NO if not
  */
-typedef void (*GST_BlacklistTestContinuation)(void *cls,
-                                              const struct GNUNET_PeerIdentity *peer,
-                                              int result);
+typedef void (*GST_BlacklistTestContinuation) (void *cls,
+                                               const struct GNUNET_PeerIdentity
+                                               * peer, int result);
 
 
 /**
@@ -111,20 +109,21 @@ typedef void (*GST_BlacklistTestContinuation)(void *cls,
  * @return handle to the blacklist check, NULL if the decision
  *        was made instantly and 'cont' was already called
  */
-struct GST_BlacklistCheck *
-GST_blacklist_test_allowed (const struct GNUNET_PeerIdentity *peer,
-                            const char *transport_name,
-                            GST_BlacklistTestContinuation cont,
-                            void *cont_cls);
-                                                 
+struct GST_BlacklistCheck *GST_blacklist_test_allowed (const struct
+                                                       GNUNET_PeerIdentity
+                                                       *peer,
+                                                       const char
+                                                       *transport_name,
+                                                       GST_BlacklistTestContinuation
+                                                       cont, void *cont_cls);
+
 
 /**
  * Cancel a blacklist check.
  * 
  * @param bc check to cancel
  */
-void
-GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc);
+void GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc);
 
 #endif
 /* end of file gnunet-service-transport_blacklist.h */
diff --git a/src/transport/gnunet-service-transport_clients.c b/src/transport/gnunet-service-transport_clients.c
index ca686057d..542e3e00b 100644
--- a/src/transport/gnunet-service-transport_clients.c
+++ b/src/transport/gnunet-service-transport_clients.c
@@ -134,13 +134,13 @@ lookup_client (struct GNUNET_SERVER_Client *client)
 {
   struct TransportClient *tc;
 
-  tc = clients_head; 
+  tc = clients_head;
   while (tc != NULL)
-    {
-      if (tc->client == client)
-        return tc;
-      tc = tc->next;
-    }
+  {
+    if (tc->client == client)
+      return tc;
+    tc = tc->next;
+  }
   return NULL;
 }
 
@@ -155,12 +155,10 @@ static struct TransportClient *
 setup_client (struct GNUNET_SERVER_Client *client)
 {
   struct TransportClient *tc;
-  
+
   tc = GNUNET_malloc (sizeof (struct TransportClient));
   tc->client = client;
-  GNUNET_CONTAINER_DLL_insert (clients_head,
-                               clients_tail,
-                               tc);
+  GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
   return tc;
 }
 
@@ -176,9 +174,7 @@ setup_client (struct GNUNET_SERVER_Client *client)
  * @return number of bytes written to buf
  */
 static size_t
-transmit_to_client_callback (void *cls, 
-                             size_t size, 
-                             void *buf)
+transmit_to_client_callback (void *cls, size_t size, void *buf)
 {
   struct TransportClient *tc = cls;
   struct ClientMessageQueueEntry *q;
@@ -189,46 +185,43 @@ transmit_to_client_callback (void *cls,
 
   tc->th = NULL;
   if (buf == NULL)
-    {
-#if DEBUG_TRANSPORT 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission to client failed, closing connection.\n");
+  {
+#if DEBUG_TRANSPORT
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission to client failed, closing connection.\n");
 #endif
-      return 0;
-    }
+    return 0;
+  }
   cbuf = buf;
   tsize = 0;
   while (NULL != (q = tc->message_queue_head))
-    {
-      msg = (const struct GNUNET_MessageHeader *) &q[1];
-      msize = ntohs (msg->size);
-      if (msize + tsize > size)
-        break;
+  {
+    msg = (const struct GNUNET_MessageHeader *) &q[1];
+    msize = ntohs (msg->size);
+    if (msize + tsize > size)
+      break;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting message of type %u to client.\n",
-                  ntohs (msg->type));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting message of type %u to client.\n",
+                ntohs (msg->type));
 #endif
-      GNUNET_CONTAINER_DLL_remove (tc->message_queue_head,
-                                   tc->message_queue_tail,
-                                   q);
-      tc->message_count--;
-      memcpy (&cbuf[tsize], 
-              msg, 
-              msize);
-      GNUNET_free (q);
-      tsize += msize;
-    }
+    GNUNET_CONTAINER_DLL_remove (tc->message_queue_head,
+                                 tc->message_queue_tail, q);
+    tc->message_count--;
+    memcpy (&cbuf[tsize], msg, msize);
+    GNUNET_free (q);
+    tsize += msize;
+  }
   if (NULL != q)
-    {
-      GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
-      tc->th = GNUNET_SERVER_notify_transmit_ready (tc->client,
-                                                    msize,
-                                                    GNUNET_TIME_UNIT_FOREVER_REL,
-                                                    &transmit_to_client_callback,
-                                                    tc);
-      GNUNET_assert (tc->th != NULL);
-    }
+  {
+    GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
+    tc->th = GNUNET_SERVER_notify_transmit_ready (tc->client,
+                                                  msize,
+                                                  GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  &transmit_to_client_callback,
+                                                  tc);
+    GNUNET_assert (tc->th != NULL);
+  }
   return tsize;
 }
 
@@ -242,43 +235,39 @@ transmit_to_client_callback (void *cls,
  */
 static void
 unicast (struct TransportClient *tc,
-         const struct GNUNET_MessageHeader *msg,
-         int may_drop)
+         const struct GNUNET_MessageHeader *msg, int may_drop)
 {
   struct ClientMessageQueueEntry *q;
   uint16_t msize;
 
-  if ( (tc->message_count >= MAX_PENDING) && 
-       (GNUNET_YES == may_drop) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Dropping message of type %u and size %u, have %u/%u messages pending\n"),
-                  ntohs (msg->type),
-                  ntohs (msg->size),
-                  tc->message_count,
-                  MAX_PENDING);
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# messages dropped due to slow client"),
-                                1,
-                                GNUNET_NO);
-      return;
-    }
+  if ((tc->message_count >= MAX_PENDING) && (GNUNET_YES == may_drop))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Dropping message of type %u and size %u, have %u/%u messages pending\n"),
+                ntohs (msg->type), ntohs (msg->size), tc->message_count,
+                MAX_PENDING);
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# messages dropped due to slow client"), 1,
+                              GNUNET_NO);
+    return;
+  }
   msize = ntohs (msg->size);
   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
   q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize);
   memcpy (&q[1], msg, msize);
   GNUNET_CONTAINER_DLL_insert_tail (tc->message_queue_head,
-                                    tc->message_queue_tail,
-                                    q);
+                                    tc->message_queue_tail, q);
   tc->message_count++;
   if (tc->th != NULL)
     return;
   tc->th = GNUNET_SERVER_notify_transmit_ready (tc->client,
-                                                msize,
-                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                                &transmit_to_client_callback,
-                                                tc);
-  GNUNET_assert (tc->th != NULL);    
+                                                msize,
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                &transmit_to_client_callback,
+                                                tc);
+  GNUNET_assert (tc->th != NULL);
 }
 
 
@@ -290,8 +279,7 @@ unicast (struct TransportClient *tc,
  * @param client identification of the client
  */
 static void
-client_disconnect_notification (void *cls,
-                                struct GNUNET_SERVER_Client *client)
+client_disconnect_notification (void *cls, struct GNUNET_SERVER_Client *client)
 {
   struct TransportClient *tc;
   struct ClientMessageQueueEntry *mqe;
@@ -306,21 +294,18 @@ client_disconnect_notification (void *cls,
               "Client disconnected, cleaning up.\n");
 #endif
   while (NULL != (mqe = tc->message_queue_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (tc->message_queue_head,
-                                   tc->message_queue_tail,
-                                   mqe);
-      tc->message_count--;
-      GNUNET_free (mqe);
-    }
-  GNUNET_CONTAINER_DLL_remove (clients_head,
-                               clients_tail,
-                               tc);
+  {
+    GNUNET_CONTAINER_DLL_remove (tc->message_queue_head,
+                                 tc->message_queue_tail, mqe);
+    tc->message_count--;
+    GNUNET_free (mqe);
+  }
+  GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
   if (tc->th != NULL)
-    {
-      GNUNET_CONNECTION_notify_transmit_ready_cancel (tc->th);
-      tc->th = NULL;
-    }
+  {
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (tc->th);
+    tc->th = NULL;
+  }
   GNUNET_break (0 == tc->message_count);
   GNUNET_free (tc);
 }
@@ -337,24 +322,25 @@ client_disconnect_notification (void *cls,
  */
 static void
 notify_client_about_neighbour (void *cls,
-                               const struct GNUNET_PeerIdentity *peer,
-                               const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                               uint32_t ats_count)
+                               const struct GNUNET_PeerIdentity *peer,
+                               const struct GNUNET_TRANSPORT_ATS_Information
+                               *ats, uint32_t ats_count)
 {
   struct TransportClient *tc = cls;
   struct ConnectInfoMessage *cim;
   size_t size;
 
-  size  = sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+  size =
+      sizeof (struct ConnectInfoMessage) +
+      ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
   GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   cim = GNUNET_malloc (size);
   cim->header.size = htons (size);
   cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
-  cim->ats_count = htonl(ats_count);
+  cim->ats_count = htonl (ats_count);
   cim->id = *peer;
   memcpy (&cim->ats,
-          ats, 
-          ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
+          ats, ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
   unicast (tc, &cim->header, GNUNET_NO);
   GNUNET_free (cim);
 }
@@ -371,35 +357,35 @@ notify_client_about_neighbour (void *cls,
  */
 static void
 clients_handle_start (void *cls,
-                      struct GNUNET_SERVER_Client *client,
-                      const struct GNUNET_MessageHeader *message)
+                      struct GNUNET_SERVER_Client *client,
+                      const struct GNUNET_MessageHeader *message)
 {
   const struct StartMessage *start;
   struct TransportClient *tc;
 
   tc = lookup_client (client);
   if (tc != NULL)
-    {
-      /* got 'start' twice from the same client, not allowed */
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
-  start = (const struct StartMessage*) message;
-  if ( (GNUNET_NO != ntohl (start->do_check)) &&
-       (0 != memcmp (&start->self,
-                     &GST_my_identity,
-                     sizeof (struct GNUNET_PeerIdentity))) )
-    {
-      /* client thinks this is a different peer, reject */
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Rejecting control connection from peer `%s', which is not me!\n"),
-                  GNUNET_i2s (&start->self));
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }  
+  {
+    /* got 'start' twice from the same client, not allowed */
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+  start = (const struct StartMessage *) message;
+  if ((GNUNET_NO != ntohl (start->do_check)) &&
+      (0 != memcmp (&start->self,
+                    &GST_my_identity, sizeof (struct GNUNET_PeerIdentity))))
+  {
+    /* client thinks this is a different peer, reject */
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Rejecting control connection from peer `%s', which is not me!\n"),
+                GNUNET_i2s (&start->self));
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   tc = setup_client (client);
-  unicast (tc, GST_hello_get(), GNUNET_NO);
+  unicast (tc, GST_hello_get (), GNUNET_NO);
   GST_neighbours_iterate (&notify_client_about_neighbour, tc);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
@@ -414,8 +400,8 @@ clients_handle_start (void *cls,
  */
 static void
 clients_handle_hello (void *cls,
-                      struct GNUNET_SERVER_Client *client,
-                      const struct GNUNET_MessageHeader *message)
+                      struct GNUNET_SERVER_Client *client,
+                      const struct GNUNET_MessageHeader *message)
 {
   GST_validation_handle_hello (message);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -447,8 +433,7 @@ struct SendTransmitContinuationContext
  * @param success GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR if we're not connected
  */
 static void
-handle_send_transmit_continuation (void *cls,
-                                   int success)
+handle_send_transmit_continuation (void *cls, int success)
 {
   struct SendTransmitContinuationContext *stcc = cls;
   struct SendOkMessage send_ok_msg;
@@ -456,9 +441,10 @@ handle_send_transmit_continuation (void *cls,
   send_ok_msg.header.size = htons (sizeof (send_ok_msg));
   send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
   send_ok_msg.success = htonl (success);
-  send_ok_msg.latency = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_FOREVER_REL);
+  send_ok_msg.latency =
+      GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_FOREVER_REL);
   send_ok_msg.peer = stcc->target;
-  GST_clients_unicast (stcc->client, &send_ok_msg.header, GNUNET_NO); 
+  GST_clients_unicast (stcc->client, &send_ok_msg.header, GNUNET_NO);
   GNUNET_SERVER_client_drop (stcc->client);
   GNUNET_free (stcc);
 }
@@ -473,8 +459,8 @@ handle_send_transmit_continuation (void *cls,
  */
 static void
 clients_handle_send (void *cls,
-                     struct GNUNET_SERVER_Client *client,
-                     const struct GNUNET_MessageHeader *message)
+                     struct GNUNET_SERVER_Client *client,
+                     const struct GNUNET_MessageHeader *message)
 {
   const struct OutboundMessage *obm;
   const struct GNUNET_MessageHeader *obmm;
@@ -483,56 +469,52 @@ clients_handle_send (void *cls,
   uint16_t msize;
 
   size = ntohs (message->size);
-  if (size < sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  if (size <
+      sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader))
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   obm = (const struct OutboundMessage *) message;
   obmm = (const struct GNUNET_MessageHeader *) &obm[1];
   msize = size - sizeof (struct OutboundMessage);
   if (msize < sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# bytes payload received for other peers"),
-                            msize,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# bytes payload received for other peers"), msize,
+                            GNUNET_NO);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' request from client with target `%4s' and first message of type %u and total size %u\n",
-              "SEND", 
-              GNUNET_i2s (&obm->peer),
-              ntohs (obmm->type),
-              msize);
+              "SEND", GNUNET_i2s (&obm->peer), ntohs (obmm->type), msize);
 #endif
-  if (GNUNET_NO == 
-      GST_neighbours_test_connected (&obm->peer))
-    {
-      /* not connected, not allowed to send; can happen due to asynchronous operations */
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# bytes payload dropped (other peer was not connected)"),
-                                msize,
-                                GNUNET_NO);
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;      
-    }
+  if (GNUNET_NO == GST_neighbours_test_connected (&obm->peer))
+  {
+    /* not connected, not allowed to send; can happen due to asynchronous operations */
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# bytes payload dropped (other peer was not connected)"),
+                              msize, GNUNET_NO);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
   stcc = GNUNET_malloc (sizeof (struct SendTransmitContinuationContext));
   stcc->target = obm->peer;
   stcc->client = client;
   GNUNET_SERVER_client_keep (client);
   GST_neighbours_send (&obm->peer,
-                       obmm, msize,
-                       GNUNET_TIME_relative_ntoh (obm->timeout),
-                       &handle_send_transmit_continuation,
-                       stcc);
+                       obmm, msize,
+                       GNUNET_TIME_relative_ntoh (obm->timeout),
+                       &handle_send_transmit_continuation, stcc);
 }
-                        
+
 
 /**
  * Try to initiate a connection to the given peer if the blacklist
@@ -545,11 +527,10 @@ clients_handle_send (void *cls,
  */
 static void
 try_connect_if_allowed (void *cls,
-                        const struct GNUNET_PeerIdentity *peer,
-                        int result)
+                        const struct GNUNET_PeerIdentity *peer, int result)
 {
   if (GNUNET_OK != result)
-    return; /* not allowed */
+    return;                     /* not allowed */
   GST_neighbours_try_connect (peer);
 }
 
@@ -563,23 +544,23 @@ try_connect_if_allowed (void *cls,
  */
 static void
 clients_handle_request_connect (void *cls,
-                                struct GNUNET_SERVER_Client *client,
-                                const struct GNUNET_MessageHeader *message)
+                                struct GNUNET_SERVER_Client *client,
+                                const struct GNUNET_MessageHeader *message)
 {
   const struct TransportRequestConnectMessage *trcm =
-    (const struct TransportRequestConnectMessage *) message;
+      (const struct TransportRequestConnectMessage *) message;
 
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# REQUEST CONNECT messages received"),
-                            1,
+                            gettext_noop
+                            ("# REQUEST CONNECT messages received"), 1,
                             GNUNET_NO);
 #if DEBUG_TRANSPORT
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 
-             "Received a request connect message for peer `%s'\n", 
-             GNUNET_i2s(&trcm->peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received a request connect message for peer `%s'\n",
+              GNUNET_i2s (&trcm->peer));
 #endif
   (void) GST_blacklist_test_allowed (&trcm->peer, NULL,
-                                     &try_connect_if_allowed, NULL);
+                                     &try_connect_if_allowed, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -593,25 +574,23 @@ clients_handle_request_connect (void *cls,
  */
 static void
 clients_handle_set_quota (void *cls,
-                          struct GNUNET_SERVER_Client *client,
-                          const struct GNUNET_MessageHeader *message)
+                          struct GNUNET_SERVER_Client *client,
+                          const struct GNUNET_MessageHeader *message)
 {
   const struct QuotaSetMessage *qsm;
 
   qsm = (const struct QuotaSetMessage *) message;
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# SET QUOTA messages received"),
-                            1,
-                            GNUNET_NO);
-#if DEBUG_TRANSPORT 
+                            gettext_noop ("# SET QUOTA messages received"),
+                            1, GNUNET_NO);
+#if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' request (new quota %u) from client for peer `%4s'\n",
               "SET_QUOTA",
-              (unsigned int) ntohl (qsm->quota.value__),
-              GNUNET_i2s (&qsm->peer));
+              (unsigned int) ntohl (qsm->quota.value__),
+              GNUNET_i2s (&qsm->peer));
 #endif
-  GST_neighbours_set_incoming_quota (&qsm->peer,
-                                     qsm->quota);
+  GST_neighbours_set_incoming_quota (&qsm->peer, qsm->quota);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -624,22 +603,20 @@ clients_handle_set_quota (void *cls,
  * @param address the resolved name, NULL to indicate the last response
  */
 static void
-transmit_address_to_client (void *cls, 
-                            const char *address)
+transmit_address_to_client (void *cls, const char *address)
 {
   struct GNUNET_SERVER_TransmitContext *tc = cls;
 
   if (NULL == address)
-    {
-      GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
-                                                  GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
-      GNUNET_SERVER_transmit_context_run (tc,
-                                          GNUNET_TIME_UNIT_FOREVER_REL);
-      return;
-    }
-  GNUNET_SERVER_transmit_context_append_data (tc, 
-                                              address, strlen (address) + 1,
-                                              GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+  {
+    GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+                                                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+    GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
+    return;
+  }
+  GNUNET_SERVER_transmit_context_append_data (tc,
+                                              address, strlen (address) + 1,
+                                              GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 }
 
 
@@ -652,8 +629,8 @@ transmit_address_to_client (void *cls,
  */
 static void
 clients_handle_address_lookup (void *cls,
-                               struct GNUNET_SERVER_Client *client,
-                               const struct GNUNET_MessageHeader *message)
+                               struct GNUNET_SERVER_Client *client,
+                               const struct GNUNET_MessageHeader *message)
 {
   const struct AddressLookupMessage *alum;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
@@ -667,46 +644,45 @@ clients_handle_address_lookup (void *cls,
 
   size = ntohs (message->size);
   if (size < sizeof (struct AddressLookupMessage))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   alum = (const struct AddressLookupMessage *) message;
   address_len = ntohl (alum->addrlen);
   if (size <= sizeof (struct AddressLookupMessage) + address_len)
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   address = (const char *) &alum[1];
   plugin_name = (const char *) &address[address_len];
   if (plugin_name
       [size - sizeof (struct AddressLookupMessage) - address_len - 1] != '\0')
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   rtimeout = GNUNET_TIME_relative_ntoh (alum->timeout);
   numeric = ntohl (alum->numeric_only);
   tc = GNUNET_SERVER_transmit_context_create (client);
   papi = GST_plugins_find (plugin_name);
   if (NULL == papi)
-    {
-      GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
-                                                  GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
-      GNUNET_SERVER_transmit_context_run (tc, rtimeout);
-      return;
-    }
+  {
+    GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+                                                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+    GNUNET_SERVER_transmit_context_run (tc, rtimeout);
+    return;
+  }
   GNUNET_SERVER_disable_receive_done_warning (client);
   papi->address_pretty_printer (papi->cls,
-                                plugin_name,
-                                address, address_len,
-                                numeric,
-                                rtimeout,
-                                &transmit_address_to_client, tc);
+                                plugin_name,
+                                address, address_len,
+                                numeric,
+                                rtimeout, &transmit_address_to_client, tc);
 }
 
 
@@ -726,28 +702,26 @@ clients_handle_address_lookup (void *cls,
  */
 static void
 send_address_to_client (void *cls,
-                        const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
-                        const struct GNUNET_PeerIdentity *target,
-                        struct GNUNET_TIME_Absolute valid_until,
-                        struct GNUNET_TIME_Absolute validation_block,
-                        const char *plugin_name,
-                        const void *plugin_address,
-                        size_t plugin_address_len)
+                        const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                        *public_key, const struct GNUNET_PeerIdentity *target,
+                        struct GNUNET_TIME_Absolute valid_until,
+                        struct GNUNET_TIME_Absolute validation_block,
+                        const char *plugin_name, const void *plugin_address,
+                        size_t plugin_address_len)
 {
   struct GNUNET_SERVER_TransmitContext *tc = cls;
   char *addr_buf;
 
   /* FIXME: move to a binary format!!! */
   GNUNET_asprintf (&addr_buf, "%s --- %s, %s",
-                   GST_plugins_a2s (plugin_name,
-                                    plugin_address,
-                                    plugin_address_len),
-                   (GNUNET_YES == GST_neighbours_test_connected (target))
-                   ? "CONNECTED"
-                   : "DISCONNECTED",
-                   (GNUNET_TIME_absolute_get_remaining (valid_until).rel_value > 0)
-                   ? "VALIDATED"
-                   : "UNVALIDATED");
+                   GST_plugins_a2s (plugin_name,
+                                    plugin_address,
+                                    plugin_address_len),
+                   (GNUNET_YES == GST_neighbours_test_connected (target))
+                   ? "CONNECTED"
+                   : "DISCONNECTED",
+                   (GNUNET_TIME_absolute_get_remaining (valid_until).rel_value >
+                    0) ? "VALIDATED" : "UNVALIDATED");
   transmit_address_to_client (tc, addr_buf);
   GNUNET_free (addr_buf);
 }
@@ -764,8 +738,8 @@ send_address_to_client (void *cls,
  */
 static void
 clients_handle_peer_address_lookup (void *cls,
-                                    struct GNUNET_SERVER_Client *client,
-                                    const struct GNUNET_MessageHeader *message)
+                                    struct GNUNET_SERVER_Client *client,
+                                    const struct GNUNET_MessageHeader *message)
 {
   const struct PeerAddressLookupMessage *peer_address_lookup;
   struct GNUNET_SERVER_TransmitContext *tc;
@@ -774,13 +748,11 @@ clients_handle_peer_address_lookup (void *cls,
   GNUNET_break (ntohl (peer_address_lookup->reserved) == 0);
   tc = GNUNET_SERVER_transmit_context_create (client);
   GST_validation_get_addresses (&peer_address_lookup->peer,
-                                &send_address_to_client,
-                                tc);
+                                &send_address_to_client, tc);
   GNUNET_SERVER_transmit_context_append_data (tc,
-                                              NULL, 0,
-                                              GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
-  GNUNET_SERVER_transmit_context_run (tc, 
-                                      GNUNET_TIME_UNIT_FOREVER_REL);
+                                              NULL, 0,
+                                              GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+  GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -794,18 +766,17 @@ clients_handle_peer_address_lookup (void *cls,
  */
 static void
 output_addresses (void *cls,
-                  const struct GNUNET_PeerIdentity *neighbour,
-                  const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                  uint32_t ats_count)
+                  const struct GNUNET_PeerIdentity *neighbour,
+                  const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                  uint32_t ats_count)
 {
   struct GNUNET_SERVER_TransmitContext *tc = cls;
   char *addr_buf;
 
   /* FIXME: move to a binary format!!! */
-  GNUNET_asprintf (&addr_buf, 
-                   "%s: %s",
-                   GNUNET_i2s(neighbour),
-                   GST_plugins_a2s ("FIXME", NULL, 0));
+  GNUNET_asprintf (&addr_buf,
+                   "%s: %s",
+                   GNUNET_i2s (neighbour), GST_plugins_a2s ("FIXME", NULL, 0));
   transmit_address_to_client (tc, addr_buf);
   GNUNET_free (addr_buf);
 }
@@ -821,15 +792,14 @@ output_addresses (void *cls,
  */
 static void
 clients_handle_address_iterate (void *cls,
-                                struct GNUNET_SERVER_Client *client,
-                                const struct GNUNET_MessageHeader *message)
-{ 
+                                struct GNUNET_SERVER_Client *client,
+                                const struct GNUNET_MessageHeader *message)
+{
   struct GNUNET_SERVER_TransmitContext *tc;
 
   GNUNET_SERVER_disable_receive_done_warning (client);
   tc = GNUNET_SERVER_transmit_context_create (client);
-  GST_neighbours_iterate (&output_addresses,
-                          tc);
+  GST_neighbours_iterate (&output_addresses, tc);
   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
   GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
@@ -841,30 +811,35 @@ clients_handle_address_iterate (void *cls,
  *
  * @param server server used to accept clients from.
  */
-void 
+void
 GST_clients_start (struct GNUNET_SERVER_Handle *server)
 {
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
-    { &clients_handle_start, NULL, 
-      GNUNET_MESSAGE_TYPE_TRANSPORT_START, sizeof (struct StartMessage)},
-    { &clients_handle_hello, NULL, 
-      GNUNET_MESSAGE_TYPE_HELLO, 0},
-    { &clients_handle_send,  NULL, 
-      GNUNET_MESSAGE_TYPE_TRANSPORT_SEND , 0},
-    { &clients_handle_request_connect, NULL,  
-      GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT, sizeof (struct TransportRequestConnectMessage)},
-    { &clients_handle_set_quota, NULL, 
-      GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)},
-    { &clients_handle_address_lookup, NULL,
-      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP , 0},
-    { &clients_handle_peer_address_lookup, NULL, 
-      GNUNET_MESSAGE_TYPE_TRANSPORT_PEER_ADDRESS_LOOKUP, sizeof (struct PeerAddressLookupMessage)},
-    { &clients_handle_address_iterate, NULL,
-      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE, sizeof (struct GNUNET_MessageHeader)},
-    { &GST_blacklist_handle_init, NULL,
-      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, sizeof (struct GNUNET_MessageHeader)},
-    { &GST_blacklist_handle_reply, NULL,
-      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, sizeof (struct BlacklistMessage)},
+    {&clients_handle_start, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_START, sizeof (struct StartMessage)},
+    {&clients_handle_hello, NULL,
+     GNUNET_MESSAGE_TYPE_HELLO, 0},
+    {&clients_handle_send, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, 0},
+    {&clients_handle_request_connect, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT,
+     sizeof (struct TransportRequestConnectMessage)},
+    {&clients_handle_set_quota, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)},
+    {&clients_handle_address_lookup, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP, 0},
+    {&clients_handle_peer_address_lookup, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_PEER_ADDRESS_LOOKUP,
+     sizeof (struct PeerAddressLookupMessage)},
+    {&clients_handle_address_iterate, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE,
+     sizeof (struct GNUNET_MessageHeader)},
+    {&GST_blacklist_handle_init, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT,
+     sizeof (struct GNUNET_MessageHeader)},
+    {&GST_blacklist_handle_reply, NULL,
+     GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY,
+     sizeof (struct BlacklistMessage)},
     {NULL, NULL, 0, 0}
   };
   GNUNET_SERVER_add_handlers (server, handlers);
@@ -890,8 +865,7 @@ GST_clients_stop ()
  * @param may_drop GNUNET_YES if the message can be dropped
  */
 void
-GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
-                       int may_drop)
+GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop)
 {
   struct TransportClient *tc;
 
@@ -909,8 +883,7 @@ GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
  */
 void
 GST_clients_unicast (struct GNUNET_SERVER_Client *client,
-                     const struct GNUNET_MessageHeader *msg,
-                     int may_drop)
+                     const struct GNUNET_MessageHeader *msg, int may_drop)
 {
   struct TransportClient *tc;
 
diff --git a/src/transport/gnunet-service-transport_clients.h b/src/transport/gnunet-service-transport_clients.h
index a9ee55279..7c79eec15 100644
--- a/src/transport/gnunet-service-transport_clients.h
+++ b/src/transport/gnunet-service-transport_clients.h
@@ -35,15 +35,13 @@
  *
  * @param server server used to accept clients from.
  */
-void 
-GST_clients_start (struct GNUNET_SERVER_Handle *server);
+void GST_clients_start (struct GNUNET_SERVER_Handle *server);
 
 
 /**
  * Stop processing clients.
  */
-void
-GST_clients_stop (void);
+void GST_clients_stop (void);
 
 
 /**
@@ -53,8 +51,7 @@ GST_clients_stop (void);
  * @param may_drop GNUNET_YES if the message can be dropped
  */
 void
-GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
-                       int may_drop);
+GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop);
 
 
 /**
@@ -66,8 +63,7 @@ GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
  */
 void
 GST_clients_unicast (struct GNUNET_SERVER_Client *client,
-                     const struct GNUNET_MessageHeader *msg,
-                     int may_drop);
+                     const struct GNUNET_MessageHeader *msg, int may_drop);
 
 
 
diff --git a/src/transport/gnunet-service-transport_hello.c b/src/transport/gnunet-service-transport_hello.c
index f05c0836a..a2d0d966c 100644
--- a/src/transport/gnunet-service-transport_hello.c
+++ b/src/transport/gnunet-service-transport_hello.c
@@ -90,7 +90,7 @@ static GST_HelloCallback hello_cb;
 
 /**
  * Closure for 'hello_cb'.
- */ 
+ */
 static void *hello_cb_cls;
 
 /**
@@ -118,7 +118,7 @@ struct GeneratorContext
    * Where are we in the DLL?
    */
   struct OwnAddressList *addr_pos;
-  
+
   /**
    * When do addresses expire?
    */
@@ -140,12 +140,11 @@ address_generator (void *cls, size_t max, void *buf)
   size_t ret;
 
   if (NULL == gc->addr_pos)
-      return 0;    
+    return 0;
   ret = GNUNET_HELLO_add_address (gc->addr_pos->plugin_name,
                                   gc->expiration,
                                   &gc->addr_pos[1],
-                                  gc->addr_pos->addrlen,
-                                  buf, max);
+                                  gc->addr_pos->addrlen, buf, max);
   gc->addr_pos = gc->addr_pos->next;
   return ret;
 }
@@ -159,34 +158,30 @@ address_generator (void *cls, size_t max, void *buf)
  * @param tc scheduler context
  */
 static void
-refresh_hello_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+refresh_hello_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GeneratorContext gc;
 
   hello_task = GNUNET_SCHEDULER_NO_TASK;
   gc.addr_pos = oal_head;
-  gc.expiration = GNUNET_TIME_relative_to_absolute (GST_HELLO_ADDRESS_EXPIRATION);
+  gc.expiration =
+      GNUNET_TIME_relative_to_absolute (GST_HELLO_ADDRESS_EXPIRATION);
   GNUNET_free (our_hello);
-  our_hello = GNUNET_HELLO_create (&GST_my_public_key, 
-                                   &address_generator, 
-                                   &gc);
+  our_hello = GNUNET_HELLO_create (&GST_my_public_key, &address_generator, &gc);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-              "Refreshed my `%s', new size is %d\n", "HELLO", 
-              GNUNET_HELLO_size(our_hello));
+              "Refreshed my `%s', new size is %d\n", "HELLO",
+              GNUNET_HELLO_size (our_hello));
 #endif
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# refreshed my HELLO"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# refreshed my HELLO"),
+                            1, GNUNET_NO);
   if (NULL != hello_cb)
-    hello_cb (hello_cb_cls, GST_hello_get());
+    hello_cb (hello_cb_cls, GST_hello_get ());
   GNUNET_PEERINFO_add_peer (GST_peerinfo, our_hello);
   hello_task
-    = GNUNET_SCHEDULER_add_delayed (HELLO_REFRESH_PERIOD,
-                                    &refresh_hello_task,
-                                    NULL);
+      = GNUNET_SCHEDULER_add_delayed (HELLO_REFRESH_PERIOD,
+                                      &refresh_hello_task, NULL);
 
 }
 
@@ -200,9 +195,7 @@ refresh_hello ()
 {
   if (hello_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (hello_task);
-  hello_task
-    = GNUNET_SCHEDULER_add_now (&refresh_hello_task,
-                                NULL);  
+  hello_task = GNUNET_SCHEDULER_add_now (&refresh_hello_task, NULL);
 }
 
 
@@ -212,14 +205,12 @@ refresh_hello ()
  * @param cb function to call whenever our HELLO changes
  * @param cb_cls closure for cb
  */
-void 
-GST_hello_start (GST_HelloCallback cb,
-                 void *cb_cls)
+void
+GST_hello_start (GST_HelloCallback cb, void *cb_cls)
 {
   hello_cb = cb;
   hello_cb_cls = cb_cls;
-  our_hello = GNUNET_HELLO_create (&GST_my_public_key, 
-                                   NULL, NULL);
+  our_hello = GNUNET_HELLO_create (&GST_my_public_key, NULL, NULL);
   refresh_hello ();
 }
 
@@ -233,15 +224,15 @@ GST_hello_stop ()
   hello_cb = NULL;
   hello_cb_cls = NULL;
   if (GNUNET_SCHEDULER_NO_TASK != hello_task)
-    {
-      GNUNET_SCHEDULER_cancel (hello_task);
-      hello_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (hello_task);
+    hello_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != our_hello)
-    {
-      GNUNET_free (our_hello);
-      our_hello = NULL;
-    }
+  {
+    GNUNET_free (our_hello);
+    our_hello = NULL;
+  }
 }
 
 
@@ -253,7 +244,7 @@ GST_hello_stop ()
 const struct GNUNET_MessageHeader *
 GST_hello_get ()
 {
-  return (struct GNUNET_MessageHeader*) our_hello;
+  return (struct GNUNET_MessageHeader *) our_hello;
 }
 
 
@@ -267,45 +258,39 @@ GST_hello_get ()
  */
 void
 GST_hello_modify_addresses (int addremove,
-                            const char *plugin_name,
-                            const void *plugin_address,
-                            size_t plugin_address_len)
+                            const char *plugin_name,
+                            const void *plugin_address,
+                            size_t plugin_address_len)
 {
   struct OwnAddressList *al;
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              (add_remove == GNUNET_YES)
-              ? "Adding `%s':%s to the set of our addresses\n"
-              : "Removing `%s':%s from the set of our addresses\n",
-              GST_plugins_a2s (plugin_name,
-                               addr, addrlen),
-              p->short_name);
+              (add_remove == GNUNET_YES)
+              ? "Adding `%s':%s to the set of our addresses\n"
+              : "Removing `%s':%s from the set of our addresses\n",
+              GST_plugins_a2s (plugin_name, addr, addrlen), p->short_name);
 #endif
   GNUNET_assert (plugin_address != NULL);
   if (GNUNET_NO == addremove)
-    {
-      for (al = oal_head; al != NULL; al = al->next)
-        if ( (plugin_address_len == al->addrlen) &&
-             (0 == strcmp (al->plugin_name, plugin_name)) &&
-             (0 == memcmp (plugin_address, &al[1], plugin_address_len)) )
-          {
-            GNUNET_CONTAINER_DLL_remove (oal_head,
-                                         oal_tail,
-                                         al);
-            GNUNET_free (al->plugin_name);
-            GNUNET_free (al);
-            refresh_hello ();
-            return;         
-          }
-      /* address to be removed not found!? */
-      GNUNET_break (0);
-      return;
-    }
+  {
+    for (al = oal_head; al != NULL; al = al->next)
+      if ((plugin_address_len == al->addrlen) &&
+          (0 == strcmp (al->plugin_name, plugin_name)) &&
+          (0 == memcmp (plugin_address, &al[1], plugin_address_len)))
+      {
+        GNUNET_CONTAINER_DLL_remove (oal_head, oal_tail, al);
+        GNUNET_free (al->plugin_name);
+        GNUNET_free (al);
+        refresh_hello ();
+        return;
+      }
+    /* address to be removed not found!? */
+    GNUNET_break (0);
+    return;
+  }
   al = GNUNET_malloc (sizeof (struct OwnAddressList) + plugin_address_len);
-  GNUNET_CONTAINER_DLL_insert (oal_head,
-                               oal_tail,
-                               al);
+  GNUNET_CONTAINER_DLL_insert (oal_head, oal_tail, al);
   al->plugin_name = GNUNET_strdup (plugin_name);
   al->addrlen = plugin_address_len;
   memcpy (&al[1], plugin_address, plugin_address_len);
@@ -327,22 +312,22 @@ GST_hello_modify_addresses (int addremove,
  */
 int
 GST_hello_test_address (const char *plugin_name,
-                        const void *plugin_address,
-                        size_t plugin_address_len,
-                        struct GNUNET_CRYPTO_RsaSignature **sig,
-                        struct GNUNET_TIME_Absolute **sig_expiration)
+                        const void *plugin_address,
+                        size_t plugin_address_len,
+                        struct GNUNET_CRYPTO_RsaSignature **sig,
+                        struct GNUNET_TIME_Absolute **sig_expiration)
 {
   struct OwnAddressList *al;
 
   for (al = oal_head; al != NULL; al = al->next)
-    if ( (plugin_address_len == al->addrlen) &&
-         (0 == strcmp (al->plugin_name, plugin_name)) &&
-         (0 == memcmp (plugin_address, &al[1], plugin_address_len)) )
-      {
-        *sig = &al->pong_signature;
-        *sig_expiration = &al->pong_sig_expires;
-        return GNUNET_YES;
-      }
+    if ((plugin_address_len == al->addrlen) &&
+        (0 == strcmp (al->plugin_name, plugin_name)) &&
+        (0 == memcmp (plugin_address, &al[1], plugin_address_len)))
+    {
+      *sig = &al->pong_signature;
+      *sig_expiration = &al->pong_sig_expires;
+      return GNUNET_YES;
+    }
   *sig = NULL;
   *sig_expiration = NULL;
   return GNUNET_NO;
diff --git a/src/transport/gnunet-service-transport_hello.h b/src/transport/gnunet-service-transport_hello.h
index 7b86d62d0..8aac2838a 100644
--- a/src/transport/gnunet-service-transport_hello.h
+++ b/src/transport/gnunet-service-transport_hello.h
@@ -45,8 +45,8 @@
  * @param cls closure
  * @param hello updated HELLO
  */
-typedef void (*GST_HelloCallback)(void *cls,
-                                  const struct GNUNET_MessageHeader *hello);
+typedef void (*GST_HelloCallback) (void *cls,
+                                   const struct GNUNET_MessageHeader * hello);
 
 
 /**
@@ -55,16 +55,13 @@ typedef void (*GST_HelloCallback)(void *cls,
  * @param cb function to call whenever our HELLO changes
  * @param cb_cls closure for cb
  */
-void 
-GST_hello_start (GST_HelloCallback cb,
-                 void *cb_cls);
+void GST_hello_start (GST_HelloCallback cb, void *cb_cls);
 
 
 /**
  * Shutdown the HELLO module.
  */
-void
-GST_hello_stop (void);
+void GST_hello_stop (void);
 
 
 /**
@@ -72,8 +69,7 @@ GST_hello_stop (void);
  *
  * @return our HELLO message
  */
-const struct GNUNET_MessageHeader *
-GST_hello_get (void);
+const struct GNUNET_MessageHeader *GST_hello_get (void);
 
 
 /**
@@ -86,9 +82,9 @@ GST_hello_get (void);
  */
 void
 GST_hello_modify_addresses (int addremove,
-                            const char *plugin_name,
-                            const void *plugin_address,
-                            size_t plugin_address_len);
+                            const char *plugin_name,
+                            const void *plugin_address,
+                            size_t plugin_address_len);
 
 
 /**
@@ -105,10 +101,10 @@ GST_hello_modify_addresses (int addremove,
  */
 int
 GST_hello_test_address (const char *plugin_name,
-                        const void *plugin_address,
-                        size_t plugin_address_len,
-                        struct GNUNET_CRYPTO_RsaSignature **sig,
-                        struct GNUNET_TIME_Absolute **sig_expiration);
+                        const void *plugin_address,
+                        size_t plugin_address_len,
+                        struct GNUNET_CRYPTO_RsaSignature **sig,
+                        struct GNUNET_TIME_Absolute **sig_expiration);
 
 
 #endif
diff --git a/src/transport/gnunet-service-transport_neighbours.c b/src/transport/gnunet-service-transport_neighbours.c
index 604112560..386894d48 100644
--- a/src/transport/gnunet-service-transport_neighbours.c
+++ b/src/transport/gnunet-service-transport_neighbours.c
@@ -152,7 +152,7 @@ struct NeighbourMapEntry
    * Address used for communicating with the peer, NULL for inbound connections.
    */
   void *addr;
-  
+
   /**
    * Number of bytes in 'addr'.
    */
@@ -236,8 +236,7 @@ static GNUNET_TRANSPORT_NotifyDisconnect disconnect_notify_cb;
 static struct NeighbourMapEntry *
 lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
 {
-  return GNUNET_CONTAINER_multihashmap_get (neighbours,
-                                            &pid->hashPubKey);
+  return GNUNET_CONTAINER_multihashmap_get (neighbours, &pid->hashPubKey);
 }
 
 
@@ -248,8 +247,7 @@ lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
  * @param tc scheduler context
  */
 static void
-transmission_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc);
+transmission_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -261,25 +259,23 @@ transmission_task (void *cls,
  */
 static void
 transmit_send_continuation (void *cls,
-                            const struct GNUNET_PeerIdentity *receiver,
-                            int success)
+                            const struct GNUNET_PeerIdentity *receiver,
+                            int success)
 {
   struct MessageQueue *mq;
   struct NeighbourMapEntry *n;
-  
+
   mq = cls;
   n = mq->n;
-  if (NULL != n) 
-    {
-      GNUNET_assert (n->is_active == mq);
-      n->is_active = NULL;
-      GNUNET_assert (n->transmission_task == GNUNET_SCHEDULER_NO_TASK);
-      n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task,
-                                                       n);
-    }
+  if (NULL != n)
+  {
+    GNUNET_assert (n->is_active == mq);
+    n->is_active = NULL;
+    GNUNET_assert (n->transmission_task == GNUNET_SCHEDULER_NO_TASK);
+    n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task, n);
+  }
   if (NULL != mq->cont)
-    mq->cont (mq->cont_cls,
-              success);
+    mq->cont (mq->cont_cls, success);
   GNUNET_free (mq);
 }
 
@@ -299,52 +295,45 @@ try_transmission_to_peer (struct NeighbourMapEntry *n)
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
 
   if (n->is_active != NULL)
-    return; /* transmission already pending */
+    return;                     /* transmission already pending */
   if (n->transmission_task != GNUNET_SCHEDULER_NO_TASK)
-    return; /* currently waiting for bandwidth */
+    return;                     /* currently waiting for bandwidth */
   mq = n->messages_head;
   while (NULL != (mq = n->messages_head))
-    {
-      timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
-      if (timeout.rel_value > 0)
-        break;
-      transmit_send_continuation (mq, &n->id, GNUNET_SYSERR); /* timeout */
-    }
+  {
+    timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
+    if (timeout.rel_value > 0)
+      break;
+    transmit_send_continuation (mq, &n->id, GNUNET_SYSERR);     /* timeout */
+  }
   if (NULL == mq)
-    return; /* no more messages */
+    return;                     /* no more messages */
 
   papi = GST_plugins_find (n->plugin_name);
   if (papi == NULL)
-    {
-      GNUNET_break (0);
-      return;
-    }
-  GNUNET_CONTAINER_DLL_remove (n->messages_head,
-                               n->messages_tail,
-                               mq);
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
   n->is_active = mq;
   mq->n = n;
   ret = papi->send (papi->cls,
-                    &n->id,
-                    mq->message_buf,
-                    mq->message_buf_size,
-                    0 /* priority -- remove from plugin API? */,
-                    timeout,
-                    n->session,
-                    n->addr,
-                    n->addrlen,
-                    GNUNET_YES,
-                    &transmit_send_continuation, mq);
+                    &n->id,
+                    mq->message_buf,
+                    mq->message_buf_size,
+                    0 /* priority -- remove from plugin API? */ ,
+                    timeout,
+                    n->session,
+                    n->addr,
+                    n->addrlen, GNUNET_YES, &transmit_send_continuation, mq);
   if (ret == -1)
-    {
-      /* failure, but 'send' would not call continuation in this case,
-         so we need to do it here! */
-      transmit_send_continuation (mq,
-                                  &n->id,
-                                  GNUNET_SYSERR);
-      n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task,
-                                                       n);
-    }
+  {
+    /* failure, but 'send' would not call continuation in this case,
+     * so we need to do it here! */
+    transmit_send_continuation (mq, &n->id, GNUNET_SYSERR);
+    n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task, n);
+  }
 }
 
 
@@ -355,8 +344,7 @@ try_transmission_to_peer (struct NeighbourMapEntry *n)
  * @param tc scheduler context
  */
 static void
-transmission_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmission_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct NeighbourMapEntry *n = cls;
 
@@ -372,10 +360,10 @@ transmission_task (void *cls,
  * @param connect_cb function to call if we connect to a peer
  * @param disconnect_cb function to call if we disconnect from a peer
  */
-void 
+void
 GST_neighbours_start (void *cls,
-                      GNUNET_TRANSPORT_NotifyConnect connect_cb,
-                      GNUNET_TRANSPORT_NotifyDisconnect disconnect_cb)
+                      GNUNET_TRANSPORT_NotifyConnect connect_cb,
+                      GNUNET_TRANSPORT_NotifyDisconnect disconnect_cb)
 {
   callback_cls = cls;
   connect_notify_cb = connect_cb;
@@ -398,57 +386,51 @@ disconnect_neighbour (struct NeighbourMapEntry *n)
     return;
   n->in_disconnect = GNUNET_YES;
   while (NULL != (mq = n->messages_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (n->messages_head,
-                                   n->messages_tail,
-                                   mq);
-      mq->cont (mq->cont_cls, GNUNET_SYSERR);
-      GNUNET_free (mq);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
+    mq->cont (mq->cont_cls, GNUNET_SYSERR);
+    GNUNET_free (mq);
+  }
   if (NULL != n->is_active)
-    {
-      n->is_active->n = NULL;
-      n->is_active = NULL;
-    }
+  {
+    n->is_active->n = NULL;
+    n->is_active = NULL;
+  }
   if (GNUNET_YES == n->is_connected)
-    {
-      n->is_connected = GNUNET_NO;
-      disconnect_notify_cb (callback_cls,
-                            &n->id);
-    }
+  {
+    n->is_connected = GNUNET_NO;
+    disconnect_notify_cb (callback_cls, &n->id);
+  }
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (neighbours,
-                                                       &n->id.hashPubKey,
-                                                       n));
+                 GNUNET_CONTAINER_multihashmap_remove (neighbours,
+                                                       &n->id.hashPubKey, n));
   if (GNUNET_SCHEDULER_NO_TASK != n->timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel (n->timeout_task);
-      n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (n->timeout_task);
+    n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != n->transmission_task)
-    {
-      GNUNET_SCHEDULER_cancel (n->timeout_task);
-      n->transmission_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (n->timeout_task);
+    n->transmission_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != n->asc)
-    {
-      GNUNET_ATS_suggest_address_cancel (n->asc);
-      n->asc = NULL;
-    }
-  GNUNET_array_grow (n->ats,
-                     n->ats_count,
-                     0);
+  {
+    GNUNET_ATS_suggest_address_cancel (n->asc);
+    n->asc = NULL;
+  }
+  GNUNET_array_grow (n->ats, n->ats_count, 0);
   if (NULL != n->plugin_name)
-    {
-      GNUNET_free (n->plugin_name);
-      n->plugin_name = NULL;
-    }
+  {
+    GNUNET_free (n->plugin_name);
+    n->plugin_name = NULL;
+  }
   if (NULL != n->addr)
-    {
-      GNUNET_free (n->addr);
-      n->addr = NULL;
-      n->addrlen = 0;
-    }
+  {
+    GNUNET_free (n->addr);
+    n->addr = NULL;
+    n->addrlen = 0;
+  }
   n->session = NULL;
   GNUNET_free (n);
 }
@@ -462,7 +444,7 @@ disconnect_neighbour (struct NeighbourMapEntry *n)
  */
 static void
 neighbour_timeout_task (void *cls,
-                        const struct GNUNET_SCHEDULER_TaskContext *tc)
+                        const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct NeighbourMapEntry *n = cls;
 
@@ -479,17 +461,14 @@ neighbour_timeout_task (void *cls,
  * @param value the 'struct NeighbourMapEntry' of the neighbour
  */
 static int
-disconnect_all_neighbours (void *cls,
-                           const GNUNET_HashCode *key,
-                           void *value)
+disconnect_all_neighbours (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct NeighbourMapEntry *n = value;
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting peer `%4s', %s\n",
-              GNUNET_i2s(&n->id),
-              "SHUTDOWN_TASK");
+              "Disconnecting peer `%4s', %s\n",
+              GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
 #endif
   disconnect_neighbour (n);
   return GNUNET_OK;
@@ -503,8 +482,7 @@ void
 GST_neighbours_stop ()
 {
   GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &disconnect_all_neighbours,
-                                         NULL);
+                                         &disconnect_all_neighbours, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (neighbours);
   neighbours = NULL;
   callback_cls = NULL;
@@ -528,46 +506,42 @@ GST_neighbours_stop ()
  */
 void
 GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
-                                  const char *plugin_name,
-                                  const void *address,
-                                  size_t address_len,
-                                  struct Session *session,
-                                  const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                                  uint32_t ats_count)
+                                  const char *plugin_name,
+                                  const void *address,
+                                  size_t address_len,
+                                  struct Session *session,
+                                  const struct GNUNET_TRANSPORT_ATS_Information
+                                  *ats, uint32_t ats_count)
 {
   struct NeighbourMapEntry *n;
   struct GNUNET_MessageHeader connect_msg;
 
   n = lookup_neighbour (peer);
   if (NULL == n)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   GNUNET_free_non_null (n->addr);
   n->addr = GNUNET_malloc (address_len);
   memcpy (n->addr, address, address_len);
   n->addrlen = address_len;
   n->session = session;
-  GNUNET_array_grow (n->ats,
-                     n->ats_count,
-                     ats_count);
+  GNUNET_array_grow (n->ats, n->ats_count, ats_count);
   memcpy (n->ats,
-          ats,
-          ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
+          ats, ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
   GNUNET_free_non_null (n->plugin_name);
   n->plugin_name = GNUNET_strdup (plugin_name);
   GNUNET_SCHEDULER_cancel (n->timeout_task);
   n->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                                  &neighbour_timeout_task, n);
+      GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                    &neighbour_timeout_task, n);
   connect_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   connect_msg.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
   GST_neighbours_send (peer,
-                       &connect_msg,
-                       sizeof (connect_msg),
-                       GNUNET_TIME_UNIT_FOREVER_REL,
-                       NULL, NULL);
+                       &connect_msg,
+                       sizeof (connect_msg),
+                       GNUNET_TIME_UNIT_FOREVER_REL, NULL, NULL);
 }
 
 
@@ -585,30 +559,25 @@ GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
  */
 static void
 try_connect_using_address (void *cls,
-                           const struct GNUNET_PeerIdentity *target,
-                           const char *plugin_name,
-                           const void *plugin_address,
-                           size_t plugin_address_len,
-                           struct GNUNET_BANDWIDTH_Value32NBO bandwidth,
-                           const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                           uint32_t ats_count)
+                           const struct GNUNET_PeerIdentity *target,
+                           const char *plugin_name,
+                           const void *plugin_address,
+                           size_t plugin_address_len,
+                           struct GNUNET_BANDWIDTH_Value32NBO bandwidth,
+                           const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                           uint32_t ats_count)
 {
   struct NeighbourMapEntry *n = cls;
 
   n->asc = NULL;
   GST_neighbours_switch_to_address (target,
-                                    plugin_name,
-                                    plugin_address,
-                                    plugin_address_len,
-                                    NULL,
-                                    ats, ats_count);
+                                    plugin_name,
+                                    plugin_address,
+                                    plugin_address_len, NULL, ats, ats_count);
   if (GNUNET_YES == n->is_connected)
     return;
-  n->is_connected = GNUNET_YES;  
-  connect_notify_cb (callback_cls,
-                     target,
-                     n->ats,
-                     n->ats_count);
+  n->is_connected = GNUNET_YES;
+  connect_notify_cb (callback_cls, target, n->ats, n->ats_count);
 }
 
 
@@ -623,33 +592,30 @@ GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target)
   struct NeighbourMapEntry *n;
 
   GNUNET_assert (0 != memcmp (target,
-                              &GST_my_identity,
-                              sizeof (struct GNUNET_PeerIdentity)));
+                              &GST_my_identity,
+                              sizeof (struct GNUNET_PeerIdentity)));
   n = lookup_neighbour (target);
-  if ( (NULL != n) &&
-       (GNUNET_YES == n->is_connected) )
-    return; /* already connected */
+  if ((NULL != n) && (GNUNET_YES == n->is_connected))
+    return;                     /* already connected */
   if (n == NULL)
-    {
-      n = GNUNET_malloc (sizeof (struct NeighbourMapEntry));
-      n->id = *target;
-      GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
-                                     GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
-                                     MAX_BANDWIDTH_CARRY_S);
-      n->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                                                      &neighbour_timeout_task, n);
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (neighbours,
-                                                        &n->id.hashPubKey,
-                                                        n,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
+  {
+    n = GNUNET_malloc (sizeof (struct NeighbourMapEntry));
+    n->id = *target;
+    GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
+                                   GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
+                                   MAX_BANDWIDTH_CARRY_S);
+    n->timeout_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                      &neighbour_timeout_task, n);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (neighbours,
+                                                      &n->id.hashPubKey, n,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
   if (n->asc != NULL)
-    return; /* already trying */
+    return;                     /* already trying */
   n->asc = GNUNET_ATS_suggest_address (GST_ats,
-                                       target,
-                                       &try_connect_using_address,
-                                       n); 
+                                       target, &try_connect_using_address, n);
 }
 
 
@@ -665,9 +631,8 @@ GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target)
   struct NeighbourMapEntry *n;
 
   n = lookup_neighbour (target);
-  if ( (NULL == n) ||
-       (n->is_connected == GNUNET_YES) )
-       return GNUNET_NO; /* not connected */
+  if ((NULL == n) || (n->is_connected == GNUNET_YES))
+    return GNUNET_NO;           /* not connected */
   return GNUNET_YES;
 }
 
@@ -680,7 +645,7 @@ GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target)
  */
 void
 GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
-                                   struct Session *session)
+                                   struct Session *session)
 {
   struct NeighbourMapEntry *n;
 
@@ -688,24 +653,23 @@ GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
   if (NULL == n)
     return;
   if (session != n->session)
-    return; /* doesn't affect us */
+    return;                     /* doesn't affect us */
   n->session = NULL;
   if (GNUNET_YES != n->is_connected)
-    return; /* not connected anymore anyway, shouldn't matter */
+    return;                     /* not connected anymore anyway, shouldn't matter */
   /* try QUICKLY to re-establish a connection, reduce timeout! */
   if (NULL != n->ats)
-    {
-      /* how can this be!? */
-      GNUNET_break (0);
-      return;
-    }
+  {
+    /* how can this be!? */
+    GNUNET_break (0);
+    return;
+  }
   GNUNET_SCHEDULER_cancel (n->timeout_task);
-  n->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                                                  &neighbour_timeout_task, n);
-  n->asc = GNUNET_ATS_suggest_address (GST_ats,
-                                       peer,
-                                       &try_connect_using_address,
-                                       n); 
+  n->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                    &neighbour_timeout_task, n);
+  n->asc =
+      GNUNET_ATS_suggest_address (GST_ats, peer, &try_connect_using_address, n);
 }
 
 
@@ -721,48 +685,42 @@ GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
  */
 void
 GST_neighbours_send (const struct GNUNET_PeerIdentity *target,
-                     const void *msg,
-                     size_t msg_size,
-                     struct GNUNET_TIME_Relative timeout,
-                     GST_NeighbourSendContinuation cont,
-                     void *cont_cls)
+                     const void *msg,
+                     size_t msg_size,
+                     struct GNUNET_TIME_Relative timeout,
+                     GST_NeighbourSendContinuation cont, void *cont_cls)
 {
   struct NeighbourMapEntry *n;
   struct MessageQueue *mq;
 
   n = lookup_neighbour (target);
-  if ( (n == NULL) ||
-       (GNUNET_YES != n->is_connected) )
-    {
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# SET QUOTA messages ignored (no such peer)"),
-                                1,
-                                GNUNET_NO);
-      if (NULL != cont)
-        cont (cont_cls,
-              GNUNET_SYSERR);
-      return;
-    }
+  if ((n == NULL) || (GNUNET_YES != n->is_connected))
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# SET QUOTA messages ignored (no such peer)"),
+                              1, GNUNET_NO);
+    if (NULL != cont)
+      cont (cont_cls, GNUNET_SYSERR);
+    return;
+  }
   GNUNET_assert (msg_size >= sizeof (struct GNUNET_MessageHeader));
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# bytes in message queue for other peers"),
-                            msg_size,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# bytes in message queue for other peers"),
+                            msg_size, GNUNET_NO);
   mq = GNUNET_malloc (sizeof (struct MessageQueue) + msg_size);
   mq->cont = cont;
   mq->cont_cls = cont_cls;
   /* FIXME: this memcpy can be up to 7% of our total runtime! */
   memcpy (&mq[1], msg, msg_size);
-  mq->message_buf = (const char*) &mq[1];
+  mq->message_buf = (const char *) &mq[1];
   mq->message_buf_size = msg_size;
   mq->timeout = GNUNET_TIME_relative_to_absolute (timeout);
-  GNUNET_CONTAINER_DLL_insert_tail (n->messages_head,
-                                    n->messages_tail,
-                                    mq);
-  if ( (GNUNET_SCHEDULER_NO_TASK == n->transmission_task) &&
-       (NULL == n->is_active) )
-    n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task,
-                                                     n);
+  GNUNET_CONTAINER_DLL_insert_tail (n->messages_head, n->messages_tail, mq);
+  if ((GNUNET_SCHEDULER_NO_TASK == n->transmission_task) &&
+      (NULL == n->is_active))
+    n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task, n);
 }
 
 
@@ -778,68 +736,64 @@ GST_neighbours_send (const struct GNUNET_PeerIdentity *target,
  * @return how long to wait before reading more from this sender
  */
 struct GNUNET_TIME_Relative
-GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity *sender,
-                                        ssize_t size,
-                                        int *do_forward)
+GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity
+                                        *sender, ssize_t size, int *do_forward)
 {
   struct NeighbourMapEntry *n;
   struct GNUNET_TIME_Relative ret;
 
   n = lookup_neighbour (sender);
   if (n == NULL)
-    {
-      *do_forward = GNUNET_NO;
-      return GNUNET_TIME_UNIT_ZERO;
-    }
-  if (GNUNET_YES == GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
-                                                      size))
-    {
-      n->quota_violation_count++;
+  {
+    *do_forward = GNUNET_NO;
+    return GNUNET_TIME_UNIT_ZERO;
+  }
+  if (GNUNET_YES == GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, size))
+  {
+    n->quota_violation_count++;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
-                  n->in_tracker.available_bytes_per_s__,
-                  n->quota_violation_count);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
+                n->in_tracker.available_bytes_per_s__,
+                n->quota_violation_count);
 #endif
-      /* Discount 32k per violation */
-      GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
-                                        - 32 * 1024);
-    }
+    /* Discount 32k per violation */
+    GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, -32 * 1024);
+  }
   else
+  {
+    if (n->quota_violation_count > 0)
     {
-      if (n->quota_violation_count > 0)
-        {
-          /* try to add 32k back */
-          GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
-                                            32 * 1024);
-          n->quota_violation_count--;
-        }
+      /* try to add 32k back */
+      GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, 32 * 1024);
+      n->quota_violation_count--;
     }
+  }
   if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
-    {
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# bandwidth quota violations by other peers"),
-                                1,
-                                GNUNET_NO);
-      *do_forward = GNUNET_NO;
-      return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
-    }
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# bandwidth quota violations by other peers"),
+                              1, GNUNET_NO);
+    *do_forward = GNUNET_NO;
+    return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
+  }
   *do_forward = GNUNET_YES;
   ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 0);
   if (ret.rel_value > 0)
-    {
-#if DEBUG_TRANSPORT 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Throttling read (%llu bytes excess at %u b/s), waiting %llu ms before reading more.\n",
-                  (unsigned long long) n->in_tracker.consumption_since_last_update__,
-                  (unsigned int) n->in_tracker.available_bytes_per_s__,
-                  (unsigned long long) ret.rel_value);
+  {
+#if DEBUG_TRANSPORT
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Throttling read (%llu bytes excess at %u b/s), waiting %llu ms before reading more.\n",
+                (unsigned long long) n->
+                in_tracker.consumption_since_last_update__,
+                (unsigned int) n->in_tracker.available_bytes_per_s__,
+                (unsigned long long) ret.rel_value);
 #endif
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# ms throttling suggested"),
-                                (int64_t) ret.rel_value,
-                                GNUNET_NO);
-    }
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop ("# ms throttling suggested"),
+                              (int64_t) ret.rel_value, GNUNET_NO);
+  }
   return ret;
 }
 
@@ -857,17 +811,17 @@ GST_neighbours_keepalive (const struct GNUNET_PeerIdentity *neighbour)
 
   n = lookup_neighbour (neighbour);
   if (NULL == n)
-    {
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# KEEPALIVE messages discarded (not connected)"),
-                                1,
-                                GNUNET_NO);
-      return;
-    }
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# KEEPALIVE messages discarded (not connected)"),
+                              1, GNUNET_NO);
+    return;
+  }
   GNUNET_SCHEDULER_cancel (n->timeout_task);
   n->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                                  &neighbour_timeout_task, n);  
+      GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                    &neighbour_timeout_task, n);
 }
 
 
@@ -879,33 +833,30 @@ GST_neighbours_keepalive (const struct GNUNET_PeerIdentity *neighbour)
  */
 void
 GST_neighbours_set_incoming_quota (const struct GNUNET_PeerIdentity *neighbour,
-                                   struct GNUNET_BANDWIDTH_Value32NBO quota)
+                                   struct GNUNET_BANDWIDTH_Value32NBO quota)
 {
   struct NeighbourMapEntry *n;
 
   n = lookup_neighbour (neighbour);
   if (n == NULL)
-    {
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# SET QUOTA messages ignored (no such peer)"),
-                                1,
-                                GNUNET_NO);
-      return;
-    }
-  GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker,
-                                         quota);
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# SET QUOTA messages ignored (no such peer)"),
+                              1, GNUNET_NO);
+    return;
+  }
+  GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker, quota);
   if (0 != ntohl (quota.value__))
     return;
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting peer `%4s' due to `%s'\n",
-              GNUNET_i2s(&n->id),
-              "SET_QUOTA");
+              "Disconnecting peer `%4s' due to `%s'\n",
+              GNUNET_i2s (&n->id), "SET_QUOTA");
 #endif
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# disconnects due to quota of 0"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# disconnects due to quota of 0"),
+                            1, GNUNET_NO);
   disconnect_neighbour (n);
 }
 
@@ -936,20 +887,15 @@ struct IteratorContext
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-neighbours_iterate (void *cls,
-                    const GNUNET_HashCode *key,
-                    void *value)
+neighbours_iterate (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct IteratorContext *ic = cls;
   struct NeighbourMapEntry *n = value;
 
   if (GNUNET_YES != n->is_connected)
-    return GNUNET_OK; 
+    return GNUNET_OK;
   GNUNET_assert (n->ats_count > 0);
-  ic->cb (ic->cb_cls,
-          &n->id,
-          n->ats,
-          n->ats_count - 1);
+  ic->cb (ic->cb_cls, &n->id, n->ats, n->ats_count - 1);
   return GNUNET_OK;
 }
 
@@ -961,16 +907,13 @@ neighbours_iterate (void *cls,
  * @param cb_cls closure for cb
  */
 void
-GST_neighbours_iterate (GST_NeighbourIterator cb,
-                        void *cb_cls)
+GST_neighbours_iterate (GST_NeighbourIterator cb, void *cb_cls)
 {
   struct IteratorContext ic;
 
   ic.cb = cb;
   ic.cb_cls = cb_cls;
-  GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &neighbours_iterate,
-                                         &ic);
+  GNUNET_CONTAINER_multihashmap_iterate (neighbours, &neighbours_iterate, &ic);
 }
 
 
@@ -987,27 +930,23 @@ GST_neighbours_force_disconnect (const struct GNUNET_PeerIdentity *target)
   struct GNUNET_MessageHeader disconnect_msg;
 
   n = lookup_neighbour (target);
-  if (NULL == n) 
-    return; /* not active */
+  if (NULL == n)
+    return;                     /* not active */
   if (GNUNET_YES == n->is_connected)
-    {
-      /* we're actually connected, send DISCONNECT message */
-      disconnect_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
-      disconnect_msg.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
-      papi = GST_plugins_find (n->plugin_name);
-      if (papi != NULL)
-        papi->send (papi->cls,
-                    target,
-                    (const void*) &disconnect_msg,
-                    sizeof (struct GNUNET_MessageHeader),
-                    UINT32_MAX /* priority */,
-                    GNUNET_TIME_UNIT_FOREVER_REL,
-                    n->session,
-                    n->addr,
-                    n->addrlen,
-                    GNUNET_YES,
-                    NULL, NULL);
-    }
+  {
+    /* we're actually connected, send DISCONNECT message */
+    disconnect_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
+    disconnect_msg.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
+    papi = GST_plugins_find (n->plugin_name);
+    if (papi != NULL)
+      papi->send (papi->cls,
+                  target,
+                  (const void *) &disconnect_msg,
+                  sizeof (struct GNUNET_MessageHeader),
+                  UINT32_MAX /* priority */ ,
+                  GNUNET_TIME_UNIT_FOREVER_REL,
+                  n->session, n->addr, n->addrlen, GNUNET_YES, NULL, NULL);
+  }
   disconnect_neighbour (n);
 }
 
diff --git a/src/transport/gnunet-service-transport_neighbours.h b/src/transport/gnunet-service-transport_neighbours.h
index a99cd1e96..c263c33d9 100644
--- a/src/transport/gnunet-service-transport_neighbours.h
+++ b/src/transport/gnunet-service-transport_neighbours.h
@@ -43,17 +43,16 @@
  * @param connect_cb function to call if we connect to a peer
  * @param disconnect_cb function to call if we disconnect from a peer
  */
-void 
+void
 GST_neighbours_start (void *cls,
-                      GNUNET_TRANSPORT_NotifyConnect connect_cb,
-                      GNUNET_TRANSPORT_NotifyDisconnect disconnect_cb);
+                      GNUNET_TRANSPORT_NotifyConnect connect_cb,
+                      GNUNET_TRANSPORT_NotifyDisconnect disconnect_cb);
 
 
 /**
  * Cleanup the neighbours subsystem.
  */
-void
-GST_neighbours_stop (void);
+void GST_neighbours_stop (void);
 
 
 /**
@@ -61,8 +60,7 @@ GST_neighbours_stop (void);
  *
  * @param target peer to try to connect to
  */
-void
-GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target);
+void GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target);
 
 
 /**
@@ -71,8 +69,7 @@ GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target);
  * @param target peer to test
  * @return GNUNET_YES if we are connected, GNUNET_NO if not
  */
-int
-GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target);
+int GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target);
 
 
 /**
@@ -81,8 +78,7 @@ GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target);
  * @param cls closure
  * @param success GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR if we're not connected
  */
-typedef void (*GST_NeighbourSendContinuation)(void *cls,
-                                              int success);
+typedef void (*GST_NeighbourSendContinuation) (void *cls, int success);
 
 
 /**
@@ -97,11 +93,10 @@ typedef void (*GST_NeighbourSendContinuation)(void *cls,
  */
 void
 GST_neighbours_send (const struct GNUNET_PeerIdentity *target,
-                     const void *msg,
-                     size_t msg_size,
-                     struct GNUNET_TIME_Relative timeout,
-                     GST_NeighbourSendContinuation cont,
-                     void *cont_cls);
+                     const void *msg,
+                     size_t msg_size,
+                     struct GNUNET_TIME_Relative timeout,
+                     GST_NeighbourSendContinuation cont, void *cont_cls);
 
 
 /**
@@ -116,9 +111,8 @@ GST_neighbours_send (const struct GNUNET_PeerIdentity *target,
  * @return how long to wait before reading more from this sender
  */
 struct GNUNET_TIME_Relative
-GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity *sender,
-                                        ssize_t size,
-                                        int *do_forward);
+GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity
+                                        *sender, ssize_t size, int *do_forward);
 
 
 /**
@@ -127,8 +121,7 @@ GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity *sender
  *
  * @param neighbour neighbour to keep alive
  */
-void
-GST_neighbours_keepalive (const struct GNUNET_PeerIdentity *neighbour);
+void GST_neighbours_keepalive (const struct GNUNET_PeerIdentity *neighbour);
 
 
 /**
@@ -139,7 +132,7 @@ GST_neighbours_keepalive (const struct GNUNET_PeerIdentity *neighbour);
  */
 void
 GST_neighbours_set_incoming_quota (const struct GNUNET_PeerIdentity *neighbour,
-                                   struct GNUNET_BANDWIDTH_Value32NBO quota);
+                                   struct GNUNET_BANDWIDTH_Value32NBO quota);
 
 
 /**
@@ -147,8 +140,7 @@ GST_neighbours_set_incoming_quota (const struct GNUNET_PeerIdentity *neighbour,
  *
  * @param target peer to disconnect from
  */
-void
-GST_neighbours_force_disconnect (const struct GNUNET_PeerIdentity *target);
+void GST_neighbours_force_disconnect (const struct GNUNET_PeerIdentity *target);
 
 
 /**
@@ -159,10 +151,12 @@ GST_neighbours_force_disconnect (const struct GNUNET_PeerIdentity *target);
  * @param ats performance data
  * @param ats_count number of entries in ats (excluding 0-termination)
  */
-typedef void (*GST_NeighbourIterator)(void *cls,
-                                      const struct GNUNET_PeerIdentity *neighbour,
-                                      const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                                      uint32_t ats_count);
+typedef void (*GST_NeighbourIterator) (void *cls,
+                                       const struct GNUNET_PeerIdentity *
+                                       neighbour,
+                                       const struct
+                                       GNUNET_TRANSPORT_ATS_Information * ats,
+                                       uint32_t ats_count);
 
 
 /**
@@ -171,9 +165,7 @@ typedef void (*GST_NeighbourIterator)(void *cls,
  * @param cb function to call 
  * @param cb_cls closure for cb
  */
-void
-GST_neighbours_iterate (GST_NeighbourIterator cb,
-                        void *cb_cls);
+void GST_neighbours_iterate (GST_NeighbourIterator cb, void *cb_cls);
 
 
 /**
@@ -184,7 +176,7 @@ GST_neighbours_iterate (GST_NeighbourIterator cb,
  */
 void
 GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
-                                   struct Session *session);
+                                   struct Session *session);
 
 
 /**
@@ -202,12 +194,12 @@ GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
  */
 void
 GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
-                                  const char *plugin_name,
-                                  const void *address,
-                                  size_t address_len,
-                                  struct Session *session,
-                                  const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                                  uint32_t ats_count);
+                                  const char *plugin_name,
+                                  const void *address,
+                                  size_t address_len,
+                                  struct Session *session,
+                                  const struct GNUNET_TRANSPORT_ATS_Information
+                                  *ats, uint32_t ats_count);
 
 
 #endif
diff --git a/src/transport/gnunet-service-transport_plugins.c b/src/transport/gnunet-service-transport_plugins.c
index 7fcc6f80d..87901d2cc 100644
--- a/src/transport/gnunet-service-transport_plugins.c
+++ b/src/transport/gnunet-service-transport_plugins.c
@@ -90,10 +90,10 @@ static struct TransportPlugin *plugins_tail;
  * @param traffic_cb function to call for flow control
  * @param session_end_cb function to call when a session was terminated
  */
-void 
+void
 GST_plugins_load (GNUNET_TRANSPORT_PluginReceiveCallback recv_cb,
-                  GNUNET_TRANSPORT_AddressNotification address_cb,
-                  GNUNET_TRANSPORT_SessionEnd session_end_cb)
+                  GNUNET_TRANSPORT_AddressNotification address_cb,
+                  GNUNET_TRANSPORT_SessionEnd session_end_cb)
 {
   struct TransportPlugin *plug;
   unsigned long long tneigh;
@@ -103,57 +103,48 @@ GST_plugins_load (GNUNET_TRANSPORT_PluginReceiveCallback recv_cb,
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (GST_cfg,
-                                             "TRANSPORT",
-                                             "NEIGHBOUR_LIMIT",
-                                             &tneigh))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Transport service is lacking NEIGHBOUR_LIMIT option.\n"));
-      return;
-    }
+                                             "TRANSPORT",
+                                             "NEIGHBOUR_LIMIT", &tneigh))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service is lacking NEIGHBOUR_LIMIT option.\n"));
+    return;
+  }
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (GST_cfg,
                                              "TRANSPORT", "PLUGINS", &plugs))
     return;
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Starting transport plugins `%s'\n"),
-              plugs);
+              _("Starting transport plugins `%s'\n"), plugs);
   for (pos = strtok (plugs, " "); pos != NULL; pos = strtok (NULL, " "))
-    {     
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Loading `%s' transport plugin\n"), pos);
-      GNUNET_asprintf (&libname, 
-                       "libgnunet_plugin_transport_%s",
-                       pos);
-      plug = GNUNET_malloc (sizeof (struct TransportPlugin));
-      plug->short_name = GNUNET_strdup (pos);
-      plug->lib_name = libname;
-      plug->env.cfg = GST_cfg;
-      plug->env.my_identity = &GST_my_identity;
-      plug->env.get_our_hello = &GST_hello_get;
-      plug->env.cls = plug->short_name;
-      plug->env.receive = recv_cb;
-      plug->env.notify_address = address_cb;
-      plug->env.session_end = session_end_cb;
-      plug->env.max_connections = tneigh;
-      plug->env.stats = GST_stats;
-      GNUNET_CONTAINER_DLL_insert (plugins_head,
-                                   plugins_tail,
-                                   plug);
-      plug->api = GNUNET_PLUGIN_load (libname, &plug->env);
-      if (plug->api == NULL)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Failed to load transport plugin for `%s'\n"), 
-                      pos);
-          GNUNET_CONTAINER_DLL_remove (plugins_head,
-                                       plugins_tail,
-                                       plug);
-          GNUNET_free (plug->short_name);
-          GNUNET_free (plug->lib_name);
-          GNUNET_free (plug);
-        }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("Loading `%s' transport plugin\n"), pos);
+    GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", pos);
+    plug = GNUNET_malloc (sizeof (struct TransportPlugin));
+    plug->short_name = GNUNET_strdup (pos);
+    plug->lib_name = libname;
+    plug->env.cfg = GST_cfg;
+    plug->env.my_identity = &GST_my_identity;
+    plug->env.get_our_hello = &GST_hello_get;
+    plug->env.cls = plug->short_name;
+    plug->env.receive = recv_cb;
+    plug->env.notify_address = address_cb;
+    plug->env.session_end = session_end_cb;
+    plug->env.max_connections = tneigh;
+    plug->env.stats = GST_stats;
+    GNUNET_CONTAINER_DLL_insert (plugins_head, plugins_tail, plug);
+    plug->api = GNUNET_PLUGIN_load (libname, &plug->env);
+    if (plug->api == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Failed to load transport plugin for `%s'\n"), pos);
+      GNUNET_CONTAINER_DLL_remove (plugins_head, plugins_tail, plug);
+      GNUNET_free (plug->short_name);
+      GNUNET_free (plug->lib_name);
+      GNUNET_free (plug);
     }
+  }
   GNUNET_free (plugs);
 }
 
@@ -167,15 +158,13 @@ GST_plugins_unload ()
   struct TransportPlugin *plug;
 
   while (NULL != (plug = plugins_head))
-    {
-      GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
-      GNUNET_free (plug->lib_name);
-      GNUNET_free (plug->short_name);
-      GNUNET_CONTAINER_DLL_remove (plugins_head,
-                                   plugins_tail,
-                                   plug);
-      GNUNET_free (plug);
-    }
+  {
+    GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
+    GNUNET_free (plug->lib_name);
+    GNUNET_free (plug->short_name);
+    GNUNET_CONTAINER_DLL_remove (plugins_head, plugins_tail, plug);
+    GNUNET_free (plug);
+  }
 }
 
 
@@ -208,20 +197,16 @@ GST_plugins_find (const char *name)
  * @return statically allocated (!) human-readable address
  */
 const char *
-GST_plugins_a2s (const char *name,
-                 const void *addr,
-                 size_t addrlen)
+GST_plugins_a2s (const char *name, const void *addr, size_t addrlen)
 {
   struct GNUNET_TRANSPORT_PluginFunctions *api;
 
   if (name == NULL)
     return NULL;
   api = GST_plugins_find (name);
-  if ( (api == NULL) || (addrlen == 0) || (addr == NULL) )
+  if ((api == NULL) || (addrlen == 0) || (addr == NULL))
     return NULL;
-  return api->address_to_string (NULL,
-                                 addr,
-                                 addrlen);
+  return api->address_to_string (NULL, addr, addrlen);
 }
 
 
diff --git a/src/transport/gnunet-service-transport_plugins.h b/src/transport/gnunet-service-transport_plugins.h
index 2852ab4bb..f3f46e342 100644
--- a/src/transport/gnunet-service-transport_plugins.h
+++ b/src/transport/gnunet-service-transport_plugins.h
@@ -42,17 +42,16 @@
  * @param address_cb function to call when our public addresses changed
  * @param session_end_cb function to call when a session was terminated
  */
-void 
+void
 GST_plugins_load (GNUNET_TRANSPORT_PluginReceiveCallback recv_cb,
-                  GNUNET_TRANSPORT_AddressNotification address_cb,
-                  GNUNET_TRANSPORT_SessionEnd session_end_cb);
+                  GNUNET_TRANSPORT_AddressNotification address_cb,
+                  GNUNET_TRANSPORT_SessionEnd session_end_cb);
 
 
 /**
  * Unload all plugins
  */
-void
-GST_plugins_unload (void);
+void GST_plugins_unload (void);
 
 
 /**
@@ -61,8 +60,7 @@ GST_plugins_unload (void);
  * @param name name of the plugin
  * @return the plugin's API, NULL if the plugin is not loaded
  */
-struct GNUNET_TRANSPORT_PluginFunctions *
-GST_plugins_find (const char *name);
+struct GNUNET_TRANSPORT_PluginFunctions *GST_plugins_find (const char *name);
 
 
 /**
@@ -74,10 +72,8 @@ GST_plugins_find (const char *name);
  * @param addrlen number of bytes in 'addr'
  * @return statically allocated (!) human-readable address
  */
-const char *
-GST_plugins_a2s (const char *name,
-                 const void *addr,
-                 size_t addrlen);
+const char *GST_plugins_a2s (const char *name,
+                             const void *addr, size_t addrlen);
 
 
 #endif
diff --git a/src/transport/gnunet-service-transport_validation.c b/src/transport/gnunet-service-transport_validation.c
index 86c51c729..f618a2b1a 100644
--- a/src/transport/gnunet-service-transport_validation.c
+++ b/src/transport/gnunet-service-transport_validation.c
@@ -66,12 +66,12 @@
 
 /**
  * Priority to use for PINGs
- */ 
+ */
 #define PING_PRIORITY 2
 
 /**
  * Priority to use for PONGs
- */ 
+ */
 #define PONG_PRIORITY 4
 
 
@@ -154,7 +154,7 @@ struct TransportPongMessage
 /**
  * Information about an address under validation
  */
-struct ValidationEntry 
+struct ValidationEntry
 {
 
   /**
@@ -176,7 +176,7 @@ struct ValidationEntry
   /**
    * Public key of the peer.
    */
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;                                                
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
 
   /**
    * The identity of the peer.
@@ -206,7 +206,7 @@ struct ValidationEntry
    * otherwise a time in the future if we're currently denying re-validation
    */
   struct GNUNET_TIME_Absolute validation_block;
-                                            
+
   /**
    * Challenge number we used.
    */
@@ -277,7 +277,7 @@ struct ValidationEntryMatchContext
    * Where to store the result?
    */
   struct ValidationEntry *ve;
-  
+
   /**
    * Transport name we're looking for.
    */
@@ -305,20 +305,18 @@ struct ValidationEntryMatchContext
  *         GNUNET_NO if the entry does match
  */
 static int
-validation_entry_match (void *cls,
-                        const GNUNET_HashCode *key,
-                        void *value)
+validation_entry_match (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct ValidationEntryMatchContext *vemc = cls;
   struct ValidationEntry *ve = value;
 
-  if ( (ve->addrlen == vemc->addrlen) &&
-       (0 == memcmp (ve->addr, vemc->addr, ve->addrlen)) &&
-       (0 == strcmp (ve->transport_name, vemc->transport_name)) )
-    {
-      vemc->ve = ve;
-      return GNUNET_NO;
-    }
+  if ((ve->addrlen == vemc->addrlen) &&
+      (0 == memcmp (ve->addr, vemc->addr, ve->addrlen)) &&
+      (0 == strcmp (ve->transport_name, vemc->transport_name)))
+  {
+    vemc->ve = ve;
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -340,11 +338,9 @@ validation_entry_match (void *cls,
  *         if we don't have an existing entry and no public key was given
  */
 static struct ValidationEntry *
-find_validation_entry (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
-                       const struct GNUNET_PeerIdentity *neighbour,
-                       const char *tname,
-                       const char *addr,
-                       size_t addrlen)
+find_validation_entry (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                       *public_key, const struct GNUNET_PeerIdentity *neighbour,
+                       const char *tname, const char *addr, size_t addrlen)
 {
   struct ValidationEntryMatchContext vemc;
   struct ValidationEntry *ve;
@@ -354,26 +350,25 @@ find_validation_entry (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pub
   vemc.addr = addr;
   vemc.addrlen = addrlen;
   GNUNET_CONTAINER_multihashmap_get_multiple (validation_map,
-                                              &neighbour->hashPubKey,
-                                              &validation_entry_match,
-                                              &vemc);
+                                              &neighbour->hashPubKey,
+                                              &validation_entry_match, &vemc);
   if (NULL != (ve = vemc.ve))
     return ve;
   if (public_key == NULL)
     return NULL;
   ve = GNUNET_malloc (sizeof (struct ValidationEntry) + addrlen);
   ve->transport_name = GNUNET_strdup (tname);
-  ve->addr = (void*) &ve[1];
+  ve->addr = (void *) &ve[1];
   ve->public_key = *public_key;
   ve->pid = *neighbour;
   ve->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                            UINT32_MAX);
+                                            UINT32_MAX);
   memcpy (&ve[1], addr, addrlen);
   ve->addrlen = addrlen;
   GNUNET_CONTAINER_multihashmap_put (validation_map,
-                                     &neighbour->hashPubKey,
-                                     ve,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+                                     &neighbour->hashPubKey,
+                                     ve,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   return ve;
 }
 
@@ -391,10 +386,9 @@ find_validation_entry (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pub
  */
 static int
 add_valid_address (void *cls,
-                   const char *tname,
-                   struct GNUNET_TIME_Absolute expiration,
-                   const void *addr, 
-                   uint16_t addrlen)
+                   const char *tname,
+                   struct GNUNET_TIME_Absolute expiration,
+                   const void *addr, uint16_t addrlen)
 {
   const struct GNUNET_HELLO_Message *hello = cls;
   struct ValidationEntry *ve;
@@ -402,26 +396,20 @@ add_valid_address (void *cls,
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
 
   if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value == 0)
-    return GNUNET_OK; /* expired */
-  if ( (GNUNET_OK !=
-        GNUNET_HELLO_get_id (hello, &pid)) ||
-       (GNUNET_OK !=
-        GNUNET_HELLO_get_key (hello, &public_key)) )
-    {
-      GNUNET_break (0);
-      return GNUNET_OK; /* invalid HELLO !? */
-    }
+    return GNUNET_OK;           /* expired */
+  if ((GNUNET_OK !=
+       GNUNET_HELLO_get_id (hello, &pid)) ||
+      (GNUNET_OK != GNUNET_HELLO_get_key (hello, &public_key)))
+  {
+    GNUNET_break (0);
+    return GNUNET_OK;           /* invalid HELLO !? */
+  }
   ve = find_validation_entry (&public_key, &pid, tname, addr, addrlen);
-  ve->valid_until = GNUNET_TIME_absolute_max (ve->valid_until,
-                                              expiration);
+  ve->valid_until = GNUNET_TIME_absolute_max (ve->valid_until, expiration);
   GNUNET_ATS_address_update (GST_ats,
-                             &pid,
-                             ve->valid_until,
-                             tname,
-                             NULL,
-                             addr,
-                             addrlen,
-                             NULL, 0);
+                             &pid,
+                             ve->valid_until,
+                             tname, NULL, addr, addrlen, NULL, 0);
   return GNUNET_OK;
 }
 
@@ -436,31 +424,29 @@ add_valid_address (void *cls,
  */
 static void
 process_peerinfo_hello (void *cls,
-                        const struct GNUNET_PeerIdentity *peer,
-                        const struct GNUNET_HELLO_Message *hello,
-                        const char *err_msg)
+                        const struct GNUNET_PeerIdentity *peer,
+                        const struct GNUNET_HELLO_Message *hello,
+                        const char *err_msg)
 {
   GNUNET_assert (NULL != peer);
   if (NULL == hello)
     return;
   GNUNET_assert (NULL ==
-                 GNUNET_HELLO_iterate_addresses (hello,
-                                                 GNUNET_NO,
-                                                 &add_valid_address,
-                                                 (void*) hello));  
+                 GNUNET_HELLO_iterate_addresses (hello,
+                                                 GNUNET_NO,
+                                                 &add_valid_address,
+                                                 (void *) hello));
 }
 
 
 /**
  * Start the validation subsystem.
  */
-void 
+void
 GST_validation_start ()
 {
   validation_map = GNUNET_CONTAINER_multihashmap_create (VALIDATION_MAP_SIZE);
-  pnc = GNUNET_PEERINFO_notify (GST_cfg,
-                                &process_peerinfo_hello,
-                                NULL);
+  pnc = GNUNET_PEERINFO_notify (GST_cfg, &process_peerinfo_hello, NULL);
 }
 
 
@@ -473,27 +459,24 @@ GST_validation_start ()
  * @return GNUNET_YES (continue to iterate)
  */
 static int
-cleanup_validation_entry (void *cls,
-                          const GNUNET_HashCode *key,
-                          void *value)
+cleanup_validation_entry (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct ValidationEntry *ve = value;
-    
+
   if (NULL != ve->bc)
-    {
-      GST_blacklist_test_cancel (ve->bc);
-      ve->bc = NULL;
-    }
+  {
+    GST_blacklist_test_cancel (ve->bc);
+    ve->bc = NULL;
+  }
   GNUNET_break (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_remove (validation_map,
-                                                      &ve->pid.hashPubKey,
-                                                      ve));
+                                                      &ve->pid.hashPubKey, ve));
   GNUNET_free (ve->transport_name);
   if (GNUNET_SCHEDULER_NO_TASK != ve->timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel (ve->timeout_task);
-      ve->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ve->timeout_task);
+    ve->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_free (ve);
   return GNUNET_OK;
 }
@@ -508,17 +491,14 @@ GST_validation_stop ()
   struct CheckHelloValidatedContext *chvc;
 
   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
-                                         &cleanup_validation_entry,
-                                         NULL);
+                                         &cleanup_validation_entry, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (validation_map);
   validation_map = NULL;
   while (NULL != (chvc = chvc_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (chvc_head,
-                                   chvc_tail,
-                                   chvc);
-      GNUNET_free (chvc);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (chvc_head, chvc_tail, chvc);
+    GNUNET_free (chvc);
+  }
   GNUNET_PEERINFO_notify_cancel (pnc);
 }
 
@@ -530,16 +510,15 @@ GST_validation_stop ()
  * @param tc scheduler context (unused)
  */
 static void
-timeout_hello_validation (void *cls, 
-                          const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_hello_validation (void *cls,
+                          const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ValidationEntry *ve = cls;
 
   ve->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# address records discarded"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# address records discarded"),
+                            1, GNUNET_NO);
   cleanup_validation_entry (NULL, &ve->pid.hashPubKey, ve);
 }
 
@@ -561,13 +540,12 @@ timeout_hello_validation (void *cls,
  */
 static void
 multicast_pong (void *cls,
-                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
-                const struct GNUNET_PeerIdentity *target,
-                struct GNUNET_TIME_Absolute valid_until,
-                struct GNUNET_TIME_Absolute validation_block,
-                const char *plugin_name,
-                const void *plugin_address,
-                size_t plugin_address_len)
+                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                *public_key, const struct GNUNET_PeerIdentity *target,
+                struct GNUNET_TIME_Absolute valid_until,
+                struct GNUNET_TIME_Absolute validation_block,
+                const char *plugin_name, const void *plugin_address,
+                size_t plugin_address_len)
 {
   struct TransportPongMessage *pong = cls;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
@@ -576,16 +554,14 @@ multicast_pong (void *cls,
   if (papi == NULL)
     return;
   (void) papi->send (papi->cls,
-                     target,
-                     (const char*) pong,
-                     ntohs (pong->header.size),
-                     PONG_PRIORITY,
-                     HELLO_REVALIDATION_START_TIME,
-                     NULL,
-                     plugin_address,
-                     plugin_address_len,
-                     GNUNET_YES,
-                     NULL, NULL);
+                     target,
+                     (const char *) pong,
+                     ntohs (pong->header.size),
+                     PONG_PRIORITY,
+                     HELLO_REVALIDATION_START_TIME,
+                     NULL,
+                     plugin_address,
+                     plugin_address_len, GNUNET_YES, NULL, NULL);
 }
 
 
@@ -602,11 +578,11 @@ multicast_pong (void *cls,
  */
 void
 GST_validation_handle_ping (const struct GNUNET_PeerIdentity *sender,
-                            const struct GNUNET_MessageHeader *hdr,
-                            const char *plugin_name,
-                            struct Session *session,
-                            const void *sender_address,
-                            size_t sender_address_len)
+                            const struct GNUNET_MessageHeader *hdr,
+                            const char *plugin_name,
+                            struct Session *session,
+                            const void *sender_address,
+                            size_t sender_address_len)
 {
   const struct TransportPingMessage *ping;
   struct TransportPongMessage *pong;
@@ -620,124 +596,113 @@ GST_validation_handle_ping (const struct GNUNET_PeerIdentity *sender,
   ssize_t ret;
 
   if (ntohs (hdr->size) < sizeof (struct TransportPingMessage))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   ping = (const struct TransportPingMessage *) hdr;
   if (0 != memcmp (&ping->target,
-                   &GST_my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+                   &GST_my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# PING messages received"),
-                            1,
-                            GNUNET_NO);
-  addr = (const char*) &ping[1];
+                            gettext_noop ("# PING messages received"),
+                            1, GNUNET_NO);
+  addr = (const char *) &ping[1];
   alen = ntohs (hdr->size) - sizeof (struct TransportPingMessage);
   /* peer wants to confirm that this is one of our addresses, this is what is
-     used for address validation */
-  
+   * used for address validation */
+
   addrend = memchr (addr, '\0', alen);
   if (NULL == addrend)
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   addrend++;
-  slen = strlen(addr);
+  slen = strlen (addr);
   alen -= slen;
-  
+
   if (GNUNET_YES !=
-      GST_hello_test_address (addr,
-                              addrend,
-                              alen,
-                              &sig_cache,
-                              &sig_cache_exp))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Not confirming PING with address `%s' since I cannot confirm having this address.\n"),
-                  GST_plugins_a2s (addr,
-                                   addrend,
-                                   alen));
-      return;
-    }
-  
+      GST_hello_test_address (addr, addrend, alen, &sig_cache, &sig_cache_exp))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Not confirming PING with address `%s' since I cannot confirm having this address.\n"),
+                GST_plugins_a2s (addr, addrend, alen));
+    return;
+  }
+
   pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + alen + slen);
-  pong->header.size = htons (sizeof (struct TransportPongMessage) + alen + slen);
+  pong->header.size =
+      htons (sizeof (struct TransportPongMessage) + alen + slen);
   pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
   pong->purpose.size =
-    htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
-           sizeof (uint32_t) +
-           sizeof (struct GNUNET_TIME_AbsoluteNBO) +
-           alen + slen);
+      htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
+             sizeof (uint32_t) +
+             sizeof (struct GNUNET_TIME_AbsoluteNBO) + alen + slen);
   pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN);
   pong->challenge = ping->challenge;
-  pong->addrlen = htonl(alen + slen);
+  pong->addrlen = htonl (alen + slen);
   memcpy (&pong[1], addr, slen);
-  memcpy (&((char*)&pong[1])[slen], addrend, alen);
-  if (GNUNET_TIME_absolute_get_remaining (*sig_cache_exp).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4)
-    {
-      /* create / update cached sig */
+  memcpy (&((char *) &pong[1])[slen], addrend, alen);
+  if (GNUNET_TIME_absolute_get_remaining (*sig_cache_exp).rel_value <
+      PONG_SIGNATURE_LIFETIME.rel_value / 4)
+  {
+    /* create / update cached sig */
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Creating PONG signature to indicate ownership.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Creating PONG signature to indicate ownership.\n");
 #endif
-      *sig_cache_exp = GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
-      pong->expiration = GNUNET_TIME_absolute_hton (*sig_cache_exp);
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CRYPTO_rsa_sign (GST_my_private_key,
-                                             &pong->purpose,
-                                             sig_cache));
-    }
+    *sig_cache_exp = GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
+    pong->expiration = GNUNET_TIME_absolute_hton (*sig_cache_exp);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_rsa_sign (GST_my_private_key,
+                                           &pong->purpose, sig_cache));
+  }
   else
-    {
-      pong->expiration = GNUNET_TIME_absolute_hton (*sig_cache_exp);
-    }
+  {
+    pong->expiration = GNUNET_TIME_absolute_hton (*sig_cache_exp);
+  }
   pong->signature = *sig_cache;
 
   /* first see if the session we got this PING from can be used to transmit
-     a response reliably */
+   * a response reliably */
   papi = GST_plugins_find (plugin_name);
   if (papi == NULL)
     ret = -1;
   else
     ret = papi->send (papi->cls,
-                      sender,
-                      (const char*) pong,
-                      ntohs (pong->header.size),
-                      PONG_PRIORITY,
-                      HELLO_REVALIDATION_START_TIME,
-                      session,
-                      sender_address,
-                      sender_address_len,
-                      GNUNET_SYSERR,
-                      NULL, NULL);
+                      sender,
+                      (const char *) pong,
+                      ntohs (pong->header.size),
+                      PONG_PRIORITY,
+                      HELLO_REVALIDATION_START_TIME,
+                      session,
+                      sender_address,
+                      sender_address_len, GNUNET_SYSERR, NULL, NULL);
   if (ret != -1)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitted PONG to `%s' via reliable mechanism\n",
-                  GNUNET_i2s (sender));
-      /* done! */
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# PONGs unicast via reliable transport"),
-                                1,
-                                GNUNET_NO);
-      GNUNET_free (pong);
-      return;
-    }
-  
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitted PONG to `%s' via reliable mechanism\n",
+                GNUNET_i2s (sender));
+    /* done! */
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# PONGs unicast via reliable transport"), 1,
+                              GNUNET_NO);
+    GNUNET_free (pong);
+    return;
+  }
+
   /* no reliable method found, try transmission via all known addresses */
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# PONGs multicast to all available addresses"),
-                            1,
-                            GNUNET_NO);
-  GST_validation_get_addresses (sender,
-                                &multicast_pong,
-                                pong);
+                            gettext_noop
+                            ("# PONGs multicast to all available addresses"), 1,
+                            GNUNET_NO);
+  GST_validation_get_addresses (sender, &multicast_pong, pong);
   GNUNET_free (pong);
 }
 
@@ -749,7 +714,7 @@ struct ValidateAddressContext
 {
   /**
    * Hash of the public key of the peer whose address is being validated.
-   */ 
+   */
   struct GNUNET_PeerIdentity pid;
 
   /**
@@ -769,8 +734,7 @@ struct ValidateAddressContext
  */
 static void
 transmit_ping_if_allowed (void *cls,
-                          const struct GNUNET_PeerIdentity *pid,
-                          int result)
+                          const struct GNUNET_PeerIdentity *pid, int result)
 {
   struct ValidationEntry *ve = cls;
   struct TransportPingMessage ping;
@@ -783,63 +747,55 @@ transmit_ping_if_allowed (void *cls,
 
   ve->bc = NULL;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting plain PING to `%s'\n",
-              GNUNET_i2s (pid));  
-  ping.header.size = htons(sizeof(struct TransportPingMessage));
-  ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
-  ping.challenge = htonl(ve->challenge);
+              "Transmitting plain PING to `%s'\n", GNUNET_i2s (pid));
+  ping.header.size = htons (sizeof (struct TransportPingMessage));
+  ping.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
+  ping.challenge = htonl (ve->challenge);
   ping.target = *pid;
-  
-  slen = strlen(ve->transport_name) + 1;
+
+  slen = strlen (ve->transport_name) + 1;
   hello = GST_hello_get ();
   hsize = ntohs (hello->size);
-  tsize = sizeof(struct TransportPingMessage) + ve->addrlen + slen + hsize;
+  tsize = sizeof (struct TransportPingMessage) + ve->addrlen + slen + hsize;
   if (tsize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Not transmitting `%s' with `%s', message too big (%u bytes!). This should not happen.\n"),
-                  "HELLO",
-                  "PING",
-                  (unsigned int) tsize);
-      /* message too big (!?), get rid of HELLO */
-      hsize = 0;
-      tsize = sizeof(struct TransportPingMessage) + ve->addrlen + slen + hsize;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Not transmitting `%s' with `%s', message too big (%u bytes!). This should not happen.\n"),
+                "HELLO", "PING", (unsigned int) tsize);
+    /* message too big (!?), get rid of HELLO */
+    hsize = 0;
+    tsize = sizeof (struct TransportPingMessage) + ve->addrlen + slen + hsize;
+  }
   {
     char message_buf[tsize];
 
-    memcpy(message_buf, hello, hsize);
-    memcpy(&message_buf[hsize], &ping, sizeof (struct TransportPingMessage));
-    memcpy(&message_buf[sizeof (struct TransportPingMessage) + hsize],
-           ve->transport_name,
-           slen);
-    memcpy(&message_buf[sizeof (struct TransportPingMessage) + slen + hsize],
-           ve->addr,
-           ve->addrlen);
+    memcpy (message_buf, hello, hsize);
+    memcpy (&message_buf[hsize], &ping, sizeof (struct TransportPingMessage));
+    memcpy (&message_buf[sizeof (struct TransportPingMessage) + hsize],
+            ve->transport_name, slen);
+    memcpy (&message_buf[sizeof (struct TransportPingMessage) + slen + hsize],
+            ve->addr, ve->addrlen);
     papi = GST_plugins_find (ve->transport_name);
     if (papi == NULL)
       ret = -1;
     else
       ret = papi->send (papi->cls,
-                        pid,
-                        message_buf,
-                        tsize,
-                        PING_PRIORITY,
-                        HELLO_REVALIDATION_START_TIME,
-                        NULL /* no session */,
-                        ve->addr,
-                        ve->addrlen,
-                        GNUNET_YES,
-                        NULL, NULL);
+                        pid,
+                        message_buf,
+                        tsize,
+                        PING_PRIORITY,
+                        HELLO_REVALIDATION_START_TIME, NULL /* no session */ ,
+                        ve->addr, ve->addrlen, GNUNET_YES, NULL, NULL);
   }
   if (-1 != ret)
-    {
-      ve->send_time = GNUNET_TIME_absolute_get ();
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# PING without HELLO messages sent"),
-                                1,
-                                GNUNET_NO);
-    }
+  {
+    ve->send_time = GNUNET_TIME_absolute_get ();
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# PING without HELLO messages sent"), 1,
+                              GNUNET_NO);
+  }
 }
 
 
@@ -856,10 +812,9 @@ transmit_ping_if_allowed (void *cls,
  */
 static int
 validate_address (void *cls,
-                  const char *tname,
-                  struct GNUNET_TIME_Absolute expiration,
-                  const void *addr, 
-                  uint16_t addrlen)
+                  const char *tname,
+                  struct GNUNET_TIME_Absolute expiration,
+                  const void *addr, uint16_t addrlen)
 {
   const struct ValidateAddressContext *vac = cls;
   const struct GNUNET_PeerIdentity *pid = &vac->pid;
@@ -867,23 +822,21 @@ validate_address (void *cls,
   struct GST_BlacklistCheck *bc;
 
   if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value == 0)
-    return GNUNET_OK; /* expired */
+    return GNUNET_OK;           /* expired */
   ve = find_validation_entry (&vac->public_key, pid, tname, addr, addrlen);
   if (GNUNET_TIME_absolute_get_remaining (ve->validation_block).rel_value > 0)
-    return GNUNET_OK; /* blocked */
-  if ( (GNUNET_SCHEDULER_NO_TASK != ve->timeout_task) &&
-       (GNUNET_TIME_absolute_get_remaining (ve->valid_until).rel_value > 0) )
-    return GNUNET_OK; /* revalidation task already scheduled & still  valid */  
-  ve->validation_block = GNUNET_TIME_relative_to_absolute (HELLO_REVALIDATION_START_TIME);
+    return GNUNET_OK;           /* blocked */
+  if ((GNUNET_SCHEDULER_NO_TASK != ve->timeout_task) &&
+      (GNUNET_TIME_absolute_get_remaining (ve->valid_until).rel_value > 0))
+    return GNUNET_OK;           /* revalidation task already scheduled & still  valid */
+  ve->validation_block =
+      GNUNET_TIME_relative_to_absolute (HELLO_REVALIDATION_START_TIME);
   if (GNUNET_SCHEDULER_NO_TASK != ve->timeout_task)
     GNUNET_SCHEDULER_cancel (ve->timeout_task);
-  ve->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_REVALIDATION_START_TIME,
-                                                   &timeout_hello_validation,
-                                                   ve);
-  bc = GST_blacklist_test_allowed (pid,
-                                   tname,
-                                   &transmit_ping_if_allowed,
-                                   ve);
+  ve->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (HELLO_REVALIDATION_START_TIME,
+                                    &timeout_hello_validation, ve);
+  bc = GST_blacklist_test_allowed (pid, tname, &transmit_ping_if_allowed, ve);
   if (NULL != bc)
     ve->bc = bc;
   return GNUNET_OK;
@@ -897,8 +850,7 @@ validate_address (void *cls,
  * @param tc scheduler context (unused)
  */
 static void
-revalidate_address (void *cls, 
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+revalidate_address (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ValidationEntry *ve = cls;
   struct GNUNET_TIME_Relative delay;
@@ -907,24 +859,20 @@ revalidate_address (void *cls,
   ve->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   delay = GNUNET_TIME_absolute_get_remaining (ve->validation_block);
   if (delay.rel_value > 0)
-    {
-      /* should wait a bit longer */
-      ve->timeout_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                       &revalidate_address,
-                                                       ve);
-      return;
-    }
+  {
+    /* should wait a bit longer */
+    ve->timeout_task = GNUNET_SCHEDULER_add_delayed (delay,
+                                                     &revalidate_address, ve);
+    return;
+  }
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# address revalidations started"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# address revalidations started"),
+                            1, GNUNET_NO);
   vac.pid = ve->pid;
   vac.public_key = ve->public_key;
   validate_address (&vac,
-                    ve->transport_name,
-                    ve->valid_until,
-                    ve->addr,
-                    (uint16_t) ve->addrlen);
+                    ve->transport_name,
+                    ve->valid_until, ve->addr, (uint16_t) ve->addrlen);
 }
 
 
@@ -936,18 +884,13 @@ revalidate_address (void *cls,
  * @param buf where to add the address
  */
 static size_t
-add_valid_peer_address (void *cls,
-                        size_t max,
-                        void *buf)
+add_valid_peer_address (void *cls, size_t max, void *buf)
 {
   struct ValidationEntry *ve = cls;
 
   return GNUNET_HELLO_add_address (ve->transport_name,
-                                   ve->valid_until,
-                                   ve->addr,
-                                   ve->addrlen,
-                                   buf,
-                                   max);
+                                   ve->valid_until,
+                                   ve->addr, ve->addrlen, buf, max);
 }
 
 
@@ -960,7 +903,7 @@ add_valid_peer_address (void *cls,
  */
 void
 GST_validation_handle_pong (const struct GNUNET_PeerIdentity *sender,
-                            const struct GNUNET_MessageHeader *hdr)
+                            const struct GNUNET_MessageHeader *hdr)
 {
   const struct TransportPongMessage *pong;
   struct ValidationEntry *ve;
@@ -973,97 +916,78 @@ GST_validation_handle_pong (const struct GNUNET_PeerIdentity *sender,
   struct GNUNET_HELLO_Message *hello;
 
   if (ntohs (hdr->size) < sizeof (struct TransportPongMessage))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   GNUNET_STATISTICS_update (GST_stats,
-                            gettext_noop ("# PONG messages received"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# PONG messages received"),
+                            1, GNUNET_NO);
   pong = (const struct TransportPongMessage *) hdr;
-  addr = (const char*) &pong[1];
+  addr = (const char *) &pong[1];
   alen = ntohs (hdr->size) - sizeof (struct TransportPongMessage);
   addrend = memchr (addr, '\0', alen);
   if (NULL == addrend)
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   addrend++;
-  slen = strlen(addr);
+  slen = strlen (addr);
   alen -= slen;
-  ve = find_validation_entry (NULL,
-                              sender,
-                              addr,
-                              addrend,
-                              alen);
+  ve = find_validation_entry (NULL, sender, addr, addrend, alen);
   if (NULL == ve)
-    {
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# PONGs dropped, no matching pending validation"),
-                                1,
-                                GNUNET_NO);
-      return;
-    }
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# PONGs dropped, no matching pending validation"),
+                              1, GNUNET_NO);
+    return;
+  }
   /* now check that PONG is well-formed */
-  if (0 != memcmp (&ve->pid,
-                   sender,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
-
-  if (GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (pong->expiration)).rel_value == 0)
-    {
-      GNUNET_STATISTICS_update (GST_stats,
-                                gettext_noop ("# PONGs dropped, signature expired"),
-                                1,
-                                GNUNET_NO);
-      return;
-    }
+  if (0 != memcmp (&ve->pid, sender, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  if (GNUNET_TIME_absolute_get_remaining
+      (GNUNET_TIME_absolute_ntoh (pong->expiration)).rel_value == 0)
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              gettext_noop
+                              ("# PONGs dropped, signature expired"), 1,
+                              GNUNET_NO);
+    return;
+  }
   if (GNUNET_OK !=
       GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
-                                &pong->purpose,
-                                &pong->signature,
-                                &ve->public_key))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
-  
+                                &pong->purpose,
+                                &pong->signature, &ve->public_key))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
   /* validity achieved, remember it! */
   ve->valid_until = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
-  GNUNET_ATS_address_update (GST_ats,
-                             &ve->pid,
-                             ve->valid_until,
-                             ve->transport_name,
-                             NULL,
-                             ve->addr,
-                             ve->addrlen,
-                             NULL, 0); /* FIXME: compute and add latency here... */
+  GNUNET_ATS_address_update (GST_ats, &ve->pid, ve->valid_until, ve->transport_name, NULL, ve->addr, ve->addrlen, NULL, 0);     /* FIXME: compute and add latency here... */
 
   /* build HELLO to store in PEERINFO */
-  hello = GNUNET_HELLO_create (&ve->public_key,
-                               &add_valid_peer_address,
-                               ve);
-  GNUNET_PEERINFO_add_peer (GST_peerinfo,
-                            hello);
+  hello = GNUNET_HELLO_create (&ve->public_key, &add_valid_peer_address, ve);
+  GNUNET_PEERINFO_add_peer (GST_peerinfo, hello);
   GNUNET_free (hello);
 
   if (GNUNET_SCHEDULER_NO_TASK != ve->timeout_task)
     GNUNET_SCHEDULER_cancel (ve->timeout_task);
 
   /* randomly delay by up to 1h to avoid synchronous validations */
-  rdelay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                     60 * 60);
+  rdelay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 60 * 60);
   delay = GNUNET_TIME_relative_add (HELLO_REVALIDATION_START_TIME,
-                                    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                                                   rdelay));
-  ve->timeout_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                   &revalidate_address,
-                                                   ve);
+                                    GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_SECONDS, rdelay));
+  ve->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (delay, &revalidate_address, ve);
 }
 
 
@@ -1076,23 +1000,22 @@ GST_validation_handle_pong (const struct GNUNET_PeerIdentity *sender,
 void
 GST_validation_handle_hello (const struct GNUNET_MessageHeader *hello)
 {
-  const struct GNUNET_HELLO_Message* hm = (const struct GNUNET_HELLO_Message*) hello;
+  const struct GNUNET_HELLO_Message *hm =
+      (const struct GNUNET_HELLO_Message *) hello;
   struct ValidateAddressContext vac;
 
-  if ( (GNUNET_OK !=
-        GNUNET_HELLO_get_id (hm, &vac.pid)) ||
-       (GNUNET_OK !=
-        GNUNET_HELLO_get_key (hm, &vac.public_key)) )
-    {
-      /* malformed HELLO */
-      GNUNET_break (0);
-      return; 
-    }
+  if ((GNUNET_OK !=
+       GNUNET_HELLO_get_id (hm, &vac.pid)) ||
+      (GNUNET_OK != GNUNET_HELLO_get_key (hm, &vac.public_key)))
+  {
+    /* malformed HELLO */
+    GNUNET_break (0);
+    return;
+  }
   GNUNET_assert (NULL ==
-                 GNUNET_HELLO_iterate_addresses (hm,
-                                                 GNUNET_NO,
-                                                 &validate_address,
-                                                 &vac));
+                 GNUNET_HELLO_iterate_addresses (hm,
+                                                 GNUNET_NO,
+                                                 &validate_address, &vac));
 }
 
 
@@ -1123,21 +1046,16 @@ struct IteratorContext
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-iterate_addresses (void *cls,
-                   const GNUNET_HashCode *key,
-                   void *value)
+iterate_addresses (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct IteratorContext *ic = cls;
   struct ValidationEntry *ve = value;
 
   ic->cb (ic->cb_cls,
-          &ve->public_key,
-          &ve->pid,
-          ve->valid_until,
-          ve->validation_block,
-          ve->transport_name,
-          ve->addr,
-          ve->addrlen);
+          &ve->public_key,
+          &ve->pid,
+          ve->valid_until,
+          ve->validation_block, ve->transport_name, ve->addr, ve->addrlen);
   return GNUNET_OK;
 }
 
@@ -1156,17 +1074,15 @@ iterate_addresses (void *cls,
  */
 void
 GST_validation_get_addresses (const struct GNUNET_PeerIdentity *target,
-                              GST_ValidationAddressCallback cb,
-                              void *cb_cls)
+                              GST_ValidationAddressCallback cb, void *cb_cls)
 {
-  struct IteratorContext  ic;
+  struct IteratorContext ic;
 
   ic.cb = cb;
   ic.cb_cls = cb_cls;
   GNUNET_CONTAINER_multihashmap_get_multiple (validation_map,
-                                              &target->hashPubKey,
-                                              &iterate_addresses,
-                                              &ic);
+                                              &target->hashPubKey,
+                                              &iterate_addresses, &ic);
 }
 
 
diff --git a/src/transport/gnunet-service-transport_validation.h b/src/transport/gnunet-service-transport_validation.h
index 73d346678..bdf8bd9ed 100644
--- a/src/transport/gnunet-service-transport_validation.h
+++ b/src/transport/gnunet-service-transport_validation.h
@@ -34,15 +34,13 @@
 /**
  * Start the validation subsystem.
  */
-void 
-GST_validation_start (void);
+void GST_validation_start (void);
 
 
 /**
  * Stop the validation subsystem.
  */
-void
-GST_validation_stop (void);
+void GST_validation_stop (void);
 
 
 /**
@@ -58,11 +56,11 @@ GST_validation_stop (void);
  */
 void
 GST_validation_handle_ping (const struct GNUNET_PeerIdentity *sender,
-                            const struct GNUNET_MessageHeader *hdr,
-                            const char *plugin_name,
-                            struct Session *session,
-                            const void *sender_address,
-                            size_t sender_address_len);
+                            const struct GNUNET_MessageHeader *hdr,
+                            const char *plugin_name,
+                            struct Session *session,
+                            const void *sender_address,
+                            size_t sender_address_len);
 
 
 /**
@@ -74,7 +72,7 @@ GST_validation_handle_ping (const struct GNUNET_PeerIdentity *sender,
  */
 void
 GST_validation_handle_pong (const struct GNUNET_PeerIdentity *sender,
-                            const struct GNUNET_MessageHeader *hdr);
+                            const struct GNUNET_MessageHeader *hdr);
 
 
 /**
@@ -83,8 +81,7 @@ GST_validation_handle_pong (const struct GNUNET_PeerIdentity *sender,
  *
  * @param hello the HELLO we received
  */
-void
-GST_validation_handle_hello (const struct GNUNET_MessageHeader *hello);
+void GST_validation_handle_hello (const struct GNUNET_MessageHeader *hello);
 
 
 /**
@@ -103,14 +100,19 @@ GST_validation_handle_hello (const struct GNUNET_MessageHeader *hello);
  * @param plugin_address binary address
  * @param plugin_address_len length of address
  */
-typedef void (*GST_ValidationAddressCallback)(void *cls,
-                                              const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
-                                              const struct GNUNET_PeerIdentity *target,
-                                              struct GNUNET_TIME_Absolute valid_until,
-                                              struct GNUNET_TIME_Absolute validation_block,
-                                              const char *plugin_name,
-                                              const void *plugin_address,
-                                              size_t plugin_address_len);
+typedef void (*GST_ValidationAddressCallback) (void *cls,
+                                               const struct
+                                               GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                                               * public_key,
+                                               const struct GNUNET_PeerIdentity
+                                               * target,
+                                               struct GNUNET_TIME_Absolute
+                                               valid_until,
+                                               struct GNUNET_TIME_Absolute
+                                               validation_block,
+                                               const char *plugin_name,
+                                               const void *plugin_address,
+                                               size_t plugin_address_len);
 
 
 /**
@@ -124,8 +126,7 @@ typedef void (*GST_ValidationAddressCallback)(void *cls,
  */
 void
 GST_validation_get_addresses (const struct GNUNET_PeerIdentity *target,
-                              GST_ValidationAddressCallback cb,
-                              void *cb_cls);
+                              GST_ValidationAddressCallback cb, void *cb_cls);
 
 
 #endif
diff --git a/src/transport/gnunet-transport-certificate-creation.c b/src/transport/gnunet-transport-certificate-creation.c
index 258c9e69a..a63c21c60 100644
--- a/src/transport/gnunet-transport-certificate-creation.c
+++ b/src/transport/gnunet-transport-certificate-creation.c
@@ -29,20 +29,19 @@
 #include "gnunet_os_lib.h"
 
 
-static void 
-removecerts (const char *file1, 
-             const char *file2)
+static void
+removecerts (const char *file1, const char *file2)
 {
   if (GNUNET_DISK_file_test (file1) == GNUNET_YES)
-    {
-      CHMOD (file1, S_IWUSR | S_IRUSR);
-      REMOVE (file1);
-    }
+  {
+    CHMOD (file1, S_IWUSR | S_IRUSR);
+    REMOVE (file1);
+  }
   if (GNUNET_DISK_file_test (file2) == GNUNET_YES)
-    {
-      CHMOD (file2, S_IWUSR | S_IRUSR);
-      REMOVE (file2);
-    }
+  {
+    CHMOD (file2, S_IWUSR | S_IRUSR);
+    REMOVE (file2);
+  }
 }
 
 
@@ -54,27 +53,26 @@ main (int argc, char **argv)
   if (argc != 3)
     return 1;
   removecerts (argv[1], argv[2]);
-  close (2); /* eliminate stderr */
+  close (2);                    /* eliminate stderr */
   /* Create RSA Private Key */
   /* openssl genrsa -out $1 1024 2> /dev/null */
   openssl = GNUNET_OS_start_process (NULL, NULL,
-                                     "openssl", 
-                                     "openssl",
-                                     "genrsa", "-out", argv[1], "1024",
-                                     NULL);
+                                     "openssl",
+                                     "openssl",
+                                     "genrsa", "-out", argv[1], "1024", NULL);
   if (openssl == NULL)
     return 2;
   GNUNET_assert (GNUNET_OS_process_wait (openssl) == GNUNET_OK);
   GNUNET_OS_process_close (openssl);
-  
-  /* Create a self-signed certificate in batch mode using rsa key*/
+
+  /* Create a self-signed certificate in batch mode using rsa key */
   /* openssl req -batch -days 365 -out $2 -new -x509 -key $1 2> /dev/null */
-  openssl = GNUNET_OS_start_process (NULL, NULL, 
-                                     "openssl", 
-                                     "openssl", 
-                                     "req", "-batch", "-days", "365", 
-                                     "-out", argv[2], "-new", "-x509", "-key", argv[1], 
-                                     NULL);
+  openssl = GNUNET_OS_start_process (NULL, NULL,
+                                     "openssl",
+                                     "openssl",
+                                     "req", "-batch", "-days", "365",
+                                     "-out", argv[2], "-new", "-x509", "-key",
+                                     argv[1], NULL);
   if (openssl == NULL)
     return 3;
   GNUNET_assert (GNUNET_OS_process_wait (openssl) == GNUNET_OK);
diff --git a/src/transport/gnunet-transport-list-connections.c b/src/transport/gnunet-transport-list-connections.c
index 39950467d..d68d2fedf 100644
--- a/src/transport/gnunet-transport-list-connections.c
+++ b/src/transport/gnunet-transport-list-connections.c
@@ -41,7 +41,7 @@
 static int no_resolve;
 
 #if VERBOSE
-  static unsigned int connection_count;
+static unsigned int connection_count;
 #endif
 
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -53,14 +53,13 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
  * @param address NULL on error, otherwise 0-terminated printable UTF-8 string
  */
 static void
-process_address (void *cls,
-                          const char *address)
+process_address (void *cls, const char *address)
 {
 #if VERBOSE
   connection_count++;
 #endif
   if (address != NULL)
-    fprintf(stdout, "%s\n", address);
+    fprintf (stdout, "%s\n", address);
 }
 
 
@@ -75,18 +74,15 @@ process_address (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
 
   cfg = c;
   if (args[0] != NULL)
-    {
-      fprintf (stderr,
-               _("Invalid command line argument `%s'\n"),
-               args[0]);
-      return;
-    }
+  {
+    fprintf (stderr, _("Invalid command line argument `%s'\n"), args[0]);
+    return;
+  }
 
   GNUNET_TRANSPORT_address_iterate (cfg,
                                     GNUNET_TIME_UNIT_MINUTES,
@@ -114,7 +110,8 @@ main (int argc, char *const *argv)
           GNUNET_PROGRAM_run (argc,
                               argv,
                               "gnunet-list-connections",
-                              gettext_noop ("Print information about connected peers."),
+                              gettext_noop
+                              ("Print information about connected peers."),
                               options, &run, NULL)) ? 0 : 1;
 }
 
diff --git a/src/transport/gnunet-transport-wlan-helper.c b/src/transport/gnunet-transport-wlan-helper.c
index a00b28854..1cfcf2c4e 100644
--- a/src/transport/gnunet-transport-wlan-helper.c
+++ b/src/transport/gnunet-transport-wlan-helper.c
@@ -108,11 +108,11 @@ struct Hardware_Infos
 };
 
 // FIXME: inline?
-int getChannelFromFrequency(int frequency);
+int getChannelFromFrequency (int frequency);
 
 // FIXME: make nice...
 static unsigned long
-calc_crc_osdep(unsigned char * buf, int len)
+calc_crc_osdep (unsigned char *buf, int len)
 {
   unsigned long crc = 0xFFFFFFFF;
 
@@ -126,44 +126,46 @@ calc_crc_osdep(unsigned char * buf, int len)
 
 // FIXME: make nice...
 static int
-check_crc_buf_osdep(unsigned char *buf, int len)
+check_crc_buf_osdep (unsigned char *buf, int len)
 {
   unsigned long crc;
 
   if (0 > len)
     return 0;
 
-  crc = calc_crc_osdep(buf, len);
+  crc = calc_crc_osdep (buf, len);
   buf += len;
   return (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] && ((crc
-      >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3]);
+                                                                         >> 16)
+                                                                        & 0xFF)
+          == buf[2] && ((crc >> 24) & 0xFF) == buf[3]);
 }
 
 
 // FIXME: make nice...
 static int
-linux_get_channel(struct Hardware_Infos *dev)
+linux_get_channel (struct Hardware_Infos *dev)
 {
   struct iwreq wrq;
   int fd, frequency;
   int chan = 0;
 
-  memset(&wrq, 0, sizeof(struct iwreq));
+  memset (&wrq, 0, sizeof (struct iwreq));
 
-  strncpy(wrq.ifr_name, dev->iface, IFNAMSIZ );
+  strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ);
 
   fd = dev->fd_raw;
-  if (0 > ioctl(fd, SIOCGIWFREQ, &wrq))
+  if (0 > ioctl (fd, SIOCGIWFREQ, &wrq))
     return (-1);
 
   frequency = wrq.u.freq.m;
-  if (100000000 < frequency  )
+  if (100000000 < frequency)
     frequency /= 100000;
-  else if (1000000 < frequency )
+  else if (1000000 < frequency)
     frequency /= 1000;
 
   if (1000 < frequency)
-    chan = getChannelFromFrequency(frequency);
+    chan = getChannelFromFrequency (frequency);
   else
     chan = frequency;
 
@@ -173,10 +175,8 @@ linux_get_channel(struct Hardware_Infos *dev)
 
 // FIXME: make nice...
 static ssize_t
-linux_read (struct Hardware_Infos *dev,
-            unsigned char *buf,  /* FIXME: void*? */
-            size_t buf_size,
-            struct Radiotap_rx *ri)
+linux_read (struct Hardware_Infos *dev, unsigned char *buf,     /* FIXME: void*? */
+            size_t buf_size, struct Radiotap_rx *ri)
 {
   unsigned char tmpbuf[buf_size];
   ssize_t caplen;
@@ -184,178 +184,175 @@ linux_read (struct Hardware_Infos *dev,
 
   n = got_signal = got_noise = got_channel = fcs_removed = 0;
 
-  caplen = read(dev->fd_raw, tmpbuf, buf_size);
+  caplen = read (dev->fd_raw, tmpbuf, buf_size);
   if (0 > caplen)
+  {
+    if (EAGAIN == errno)
+      return 0;
+    fprintf (stderr, "Failed to read from RAW socket: %s\n", strerror (errno));
+    return -1;
+  }
+
+  memset (buf, 0, buf_size);
+  memset (ri, 0, sizeof (*ri));
+
+  switch (dev->arptype_in)
+  {
+  case ARPHRD_IEEE80211_PRISM:
+  {
+    /* skip the prism header */
+    if (tmpbuf[7] == 0x40)
     {
-      if (EAGAIN == errno)
-        return 0;
-      fprintf (stderr,
-               "Failed to read from RAW socket: %s\n",
-               strerror (errno));
-      return -1;
+      /* prism54 uses a different format */
+      ri->ri_power = tmpbuf[0x33];
+      ri->ri_noise = *(unsigned int *) (tmpbuf + 0x33 + 12);
+      ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x33 + 24)) * 500000;
+      got_signal = 1;
+      got_noise = 1;
+      n = 0x40;
+    }
+    else
+    {
+      ri->ri_mactime = *(u_int64_t *) (tmpbuf + 0x5C - 48);
+      ri->ri_channel = *(unsigned int *) (tmpbuf + 0x5C - 36);
+      ri->ri_power = *(unsigned int *) (tmpbuf + 0x5C);
+      ri->ri_noise = *(unsigned int *) (tmpbuf + 0x5C + 12);
+      ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x5C + 24)) * 500000;
+      got_channel = 1;
+      got_signal = 1;
+      got_noise = 1;
+      n = *(int *) (tmpbuf + 4);
     }
 
-  memset(buf, 0, buf_size);
-  memset(ri, 0, sizeof(*ri));
+    if (n < 8 || n >= caplen)
+      return (0);
+  }
+    break;
 
-  switch (dev->arptype_in)
+  case ARPHRD_IEEE80211_FULL:
+  {
+    struct ieee80211_radiotap_iterator iterator;
+    struct ieee80211_radiotap_header *rthdr;
+
+    rthdr = (struct ieee80211_radiotap_header *) tmpbuf;
+
+    if (ieee80211_radiotap_iterator_init (&iterator, rthdr, caplen) < 0)
+      return (0);
+
+    /* go through the radiotap arguments we have been given
+     * by the driver
+     */
+
+    while (ieee80211_radiotap_iterator_next (&iterator) >= 0)
     {
-    case ARPHRD_IEEE80211_PRISM:
-      {
-        /* skip the prism header */
-        if (tmpbuf[7] == 0x40)
-          {
-            /* prism54 uses a different format */
-            ri->ri_power = tmpbuf[0x33];
-            ri->ri_noise = *(unsigned int *) (tmpbuf + 0x33 + 12);
-            ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x33 + 24)) * 500000;
-            got_signal = 1;
-            got_noise = 1;
-            n = 0x40;
-          }
-        else
-          {
-            ri->ri_mactime = *(u_int64_t*) (tmpbuf + 0x5C - 48);
-            ri->ri_channel = *(unsigned int *) (tmpbuf + 0x5C - 36);
-            ri->ri_power = *(unsigned int *) (tmpbuf + 0x5C);
-            ri->ri_noise = *(unsigned int *) (tmpbuf + 0x5C + 12);
-            ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x5C + 24)) * 500000;
-            got_channel = 1;
-            got_signal = 1;
-            got_noise = 1;
-            n = *(int *) (tmpbuf + 4);
-          }
-        
-        if (n < 8 || n >= caplen)
-          return (0);
-      }
-      break;
 
-    case ARPHRD_IEEE80211_FULL:
+      switch (iterator.this_arg_index)
       {
-        struct ieee80211_radiotap_iterator iterator;
-        struct ieee80211_radiotap_header *rthdr;
-        
-        rthdr = (struct ieee80211_radiotap_header *) tmpbuf;
-        
-        if (ieee80211_radiotap_iterator_init(&iterator, rthdr, caplen) < 0)
-          return (0);
-        
-        /* go through the radiotap arguments we have been given
-         * by the driver
-         */
-        
-        while (ieee80211_radiotap_iterator_next(&iterator) >= 0)
-          {
-            
-            switch (iterator.this_arg_index)
-              {
-                
-              case IEEE80211_RADIOTAP_TSFT:
-                ri->ri_mactime = le64_to_cpu(*((uint64_t*) iterator.this_arg));
-                break;
-                
-              case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
-                if (!got_signal)
-                  {
-                    if (*iterator.this_arg < 127)
-                      ri->ri_power = *iterator.this_arg;
-                    else
-                      ri->ri_power = *iterator.this_arg - 255;
-                    
-                    got_signal = 1;
-                  }
-                break;
-                
-              case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
-                if (!got_signal)
-                  {
-                    if (*iterator.this_arg < 127)
-                      ri->ri_power = *iterator.this_arg;
-                    else
-                      ri->ri_power = *iterator.this_arg - 255;
-                    
-                    got_signal = 1;
-                  }
-                break;
-                
-              case IEEE80211_RADIOTAP_DBM_ANTNOISE:
-                if (!got_noise)
-                  {
-                    if (*iterator.this_arg < 127)
-                      ri->ri_noise = *iterator.this_arg;
-                    else
-                      ri->ri_noise = *iterator.this_arg - 255;
-                    
-                    got_noise = 1;
-                  }
-                break;
-                
-              case IEEE80211_RADIOTAP_DB_ANTNOISE:
-                if (!got_noise)
-                  {
-                    if (*iterator.this_arg < 127)
-                      ri->ri_noise = *iterator.this_arg;
-                    else
-                      ri->ri_noise = *iterator.this_arg - 255;
-                    
-                    got_noise = 1;
-                  }
-                break;
-                
-              case IEEE80211_RADIOTAP_ANTENNA:
-                ri->ri_antenna = *iterator.this_arg;
-                break;
-                
-              case IEEE80211_RADIOTAP_CHANNEL:
-                ri->ri_channel = *iterator.this_arg;
-                got_channel = 1;
-                break;
-                
-              case IEEE80211_RADIOTAP_RATE:
-                ri->ri_rate = (*iterator.this_arg) * 500000;
-                break;
-                
-              case IEEE80211_RADIOTAP_FLAGS:
-                /* is the CRC visible at the end?
-                 * remove
-                 */
-                if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS)
-                  {
-                    fcs_removed = 1;
-                    caplen -= 4;
-                  }
-                
-                if (*iterator.this_arg & IEEE80211_RADIOTAP_F_RX_BADFCS)
-                  return (0);
-                
-                break;      
-              }
-          }     
-        n = le16_to_cpu(rthdr->it_len); 
-        if (n <= 0 || n >= caplen)
-          return 0;
+
+      case IEEE80211_RADIOTAP_TSFT:
+        ri->ri_mactime = le64_to_cpu (*((uint64_t *) iterator.this_arg));
+        break;
+
+      case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
+        if (!got_signal)
+        {
+          if (*iterator.this_arg < 127)
+            ri->ri_power = *iterator.this_arg;
+          else
+            ri->ri_power = *iterator.this_arg - 255;
+
+          got_signal = 1;
+        }
+        break;
+
+      case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
+        if (!got_signal)
+        {
+          if (*iterator.this_arg < 127)
+            ri->ri_power = *iterator.this_arg;
+          else
+            ri->ri_power = *iterator.this_arg - 255;
+
+          got_signal = 1;
+        }
+        break;
+
+      case IEEE80211_RADIOTAP_DBM_ANTNOISE:
+        if (!got_noise)
+        {
+          if (*iterator.this_arg < 127)
+            ri->ri_noise = *iterator.this_arg;
+          else
+            ri->ri_noise = *iterator.this_arg - 255;
+
+          got_noise = 1;
+        }
+        break;
+
+      case IEEE80211_RADIOTAP_DB_ANTNOISE:
+        if (!got_noise)
+        {
+          if (*iterator.this_arg < 127)
+            ri->ri_noise = *iterator.this_arg;
+          else
+            ri->ri_noise = *iterator.this_arg - 255;
+
+          got_noise = 1;
+        }
+        break;
+
+      case IEEE80211_RADIOTAP_ANTENNA:
+        ri->ri_antenna = *iterator.this_arg;
+        break;
+
+      case IEEE80211_RADIOTAP_CHANNEL:
+        ri->ri_channel = *iterator.this_arg;
+        got_channel = 1;
+        break;
+
+      case IEEE80211_RADIOTAP_RATE:
+        ri->ri_rate = (*iterator.this_arg) * 500000;
+        break;
+
+      case IEEE80211_RADIOTAP_FLAGS:
+        /* is the CRC visible at the end?
+         * remove
+         */
+        if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS)
+        {
+          fcs_removed = 1;
+          caplen -= 4;
+        }
+
+        if (*iterator.this_arg & IEEE80211_RADIOTAP_F_RX_BADFCS)
+          return (0);
+
+        break;
       }
-      break;
-    case ARPHRD_IEEE80211:
-      /* do nothing? */
-      break;
-    default:
-      errno = ENOTSUP;
-      return -1;
     }
+    n = le16_to_cpu (rthdr->it_len);
+    if (n <= 0 || n >= caplen)
+      return 0;
+  }
+    break;
+  case ARPHRD_IEEE80211:
+    /* do nothing? */
+    break;
+  default:
+    errno = ENOTSUP;
+    return -1;
+  }
 
   caplen -= n;
 
   //detect fcs at the end, even if the flag wasn't set and remove it
-  if ( (0 == fcs_removed) && 
-       (1 == check_crc_buf_osdep(tmpbuf + n, caplen - 4)) )
-    {
-      caplen -= 4;
-    }
-  memcpy(buf, tmpbuf + n, caplen);
-  if (! got_channel)
-    ri->ri_channel = linux_get_channel(dev);
+  if ((0 == fcs_removed) && (1 == check_crc_buf_osdep (tmpbuf + n, caplen - 4)))
+  {
+    caplen -= 4;
+  }
+  memcpy (buf, tmpbuf + n, caplen);
+  if (!got_channel)
+    ri->ri_channel = linux_get_channel (dev);
 
   return caplen;
 }
@@ -373,122 +370,108 @@ openraw (struct Hardware_Infos *dev)
   struct sockaddr_ll sll;
 
   /* find the interface index */
-  memset(&ifr, 0, sizeof(ifr));
-  strncpy(ifr.ifr_name, dev->iface, IFNAMSIZ);
-  if (-1 == ioctl(dev->fd_raw, SIOCGIFINDEX, &ifr))
-    {
-      fprintf (stderr,
-               "Line: 381 ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n",
-               IFNAMSIZ,
-               dev->iface,
-               strerror (errno));
-      return 1;
-    }
+  memset (&ifr, 0, sizeof (ifr));
+  strncpy (ifr.ifr_name, dev->iface, IFNAMSIZ);
+  if (-1 == ioctl (dev->fd_raw, SIOCGIFINDEX, &ifr))
+  {
+    fprintf (stderr,
+             "Line: 381 ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n",
+             IFNAMSIZ, dev->iface, strerror (errno));
+    return 1;
+  }
 
   /* lookup the hardware type */
-  memset (&sll, 0, sizeof(sll));
+  memset (&sll, 0, sizeof (sll));
   sll.sll_family = AF_PACKET;
   sll.sll_ifindex = ifr.ifr_ifindex;
-  sll.sll_protocol = htons(ETH_P_ALL);
-  if (-1 == ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr))
-    {
-      fprintf (stderr,
-               "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
-               IFNAMSIZ,
-               dev->iface,
-               strerror (errno));
-      return 1;
-    }
+  sll.sll_protocol = htons (ETH_P_ALL);
+  if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr))
+  {
+    fprintf (stderr,
+             "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
+             IFNAMSIZ, dev->iface, strerror (errno));
+    return 1;
+  }
 
   /* lookup iw mode */
-  memset(&wrq, 0, sizeof(struct iwreq));
-  strncpy(wrq.ifr_name, dev->iface, IFNAMSIZ);
-  if (-1 == ioctl(dev->fd_raw, SIOCGIWMODE, &wrq))
-    {
-      /* most probably not supported (ie for rtap ipw interface) *
-       * so just assume its correctly set...                     */
-      wrq.u.mode = IW_MODE_MONITOR;
-    }
-
-  if ( ( (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && 
-         (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && 
-         (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL) ) || 
-       (wrq.u.mode != IW_MODE_MONITOR) )
-    {
-      fprintf (stderr,
-               "Error: interface `%.*s' is not in monitor mode\n", 
-               IFNAMSIZ,
-               dev->iface);
-      return 1;
-    }
+  memset (&wrq, 0, sizeof (struct iwreq));
+  strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ);
+  if (-1 == ioctl (dev->fd_raw, SIOCGIWMODE, &wrq))
+  {
+    /* most probably not supported (ie for rtap ipw interface) *
+     * so just assume its correctly set...                     */
+    wrq.u.mode = IW_MODE_MONITOR;
+  }
+
+  if (((ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) &&
+       (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) &&
+       (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL)) ||
+      (wrq.u.mode != IW_MODE_MONITOR))
+  {
+    fprintf (stderr,
+             "Error: interface `%.*s' is not in monitor mode\n",
+             IFNAMSIZ, dev->iface);
+    return 1;
+  }
 
   /* Is interface st to up, broadcast & running ? */
   if ((ifr.ifr_flags | IFF_UP | IFF_BROADCAST | IFF_RUNNING) != ifr.ifr_flags)
-    {
-      /* Bring interface up*/
-      ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING;
+  {
+    /* Bring interface up */
+    ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING;
 
-      if (-1 == ioctl(dev->fd_raw, SIOCSIFFLAGS, &ifr))
-        {
-          fprintf (stderr,
-                   "Line: 434 ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n",
-                   IFNAMSIZ,
-                   dev->iface,
-                   strerror (errno));
-          return 1;
-        }
-    }
-
-  /* bind the raw socket to the interface */
-  if (-1 == bind(dev->fd_raw, (struct sockaddr *) &sll, sizeof(sll)))
+    if (-1 == ioctl (dev->fd_raw, SIOCSIFFLAGS, &ifr))
     {
       fprintf (stderr,
-               "Failed to bind interface `%.*s': %s\n",
-               IFNAMSIZ,
-               dev->iface,
-               strerror (errno));
+               "Line: 434 ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n",
+               IFNAMSIZ, dev->iface, strerror (errno));
       return 1;
     }
+  }
+
+  /* bind the raw socket to the interface */
+  if (-1 == bind (dev->fd_raw, (struct sockaddr *) &sll, sizeof (sll)))
+  {
+    fprintf (stderr,
+             "Failed to bind interface `%.*s': %s\n",
+             IFNAMSIZ, dev->iface, strerror (errno));
+    return 1;
+  }
 
   /* lookup the hardware type */
-  if (-1 == ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr))
-    {
-      fprintf (stderr,
-               "Line: 457 ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
-               IFNAMSIZ,
-               dev->iface,
-               strerror (errno));
-      return 1;
-    }
+  if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr))
+  {
+    fprintf (stderr,
+             "Line: 457 ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n",
+             IFNAMSIZ, dev->iface, strerror (errno));
+    return 1;
+  }
 
-  memcpy (dev->pl_mac, 
-          ifr.ifr_hwaddr.sa_data, 
-          MAC_ADDR_SIZE);
+  memcpy (dev->pl_mac, ifr.ifr_hwaddr.sa_data, MAC_ADDR_SIZE);
   dev->arptype_in = ifr.ifr_hwaddr.sa_family;
-  if ( (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && 
-       (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && 
-       (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL) )
-    {
-      fprintf (stderr,
-               "Unsupported hardware link type %d on interface `%.*s'\n",
-               ifr.ifr_hwaddr.sa_family,
-               IFNAMSIZ,
-               dev->iface);
-      return 1;
-    }
+  if ((ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) &&
+      (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) &&
+      (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL))
+  {
+    fprintf (stderr,
+             "Unsupported hardware link type %d on interface `%.*s'\n",
+             ifr.ifr_hwaddr.sa_family, IFNAMSIZ, dev->iface);
+    return 1;
+  }
 
   /* enable promiscuous mode */
-  memset(&mr, 0, sizeof(mr));
+  memset (&mr, 0, sizeof (mr));
   mr.mr_ifindex = sll.sll_ifindex;
   mr.mr_type = PACKET_MR_PROMISC;
-  if (0 != setsockopt(dev->fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr, sizeof(mr)))
-    {
-      fprintf (stderr,
-               "Failed to enable promiscuous mode on interface `%.*s'\n",
-               IFNAMSIZ,
-               dev->iface);
-      return 1;
-    }
+  if (0 !=
+      setsockopt (dev->fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr,
+                  sizeof (mr)))
+  {
+    fprintf (stderr,
+             "Failed to enable promiscuous mode on interface `%.*s'\n",
+             IFNAMSIZ, dev->iface);
+    return 1;
+  }
 
   return 0;
 }
@@ -497,52 +480,43 @@ openraw (struct Hardware_Infos *dev)
  * @return 0 on success
  */
 static int
-wlaninit (struct Hardware_Infos *dev, 
-          const char *iface)
+wlaninit (struct Hardware_Infos *dev, const char *iface)
 {
   char strbuf[512];
   struct stat sbuf;
   int ret;
 
-  dev->fd_raw = socket (PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
+  dev->fd_raw = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL));
   if (0 > dev->fd_raw)
-    {
-      fprintf (stderr,
-               "Failed to create raw socket: %s\n",
-               strerror (errno));
-      return 1;
-    }
+  {
+    fprintf (stderr, "Failed to create raw socket: %s\n", strerror (errno));
+    return 1;
+  }
   if (dev->fd_raw >= FD_SETSIZE)
-    {
-      fprintf (stderr,
-               "File descriptor too large for select (%d > %d)\n",
-               dev->fd_raw,
-               FD_SETSIZE);
-      close (dev->fd_raw);
-      return 1;
-    }
+  {
+    fprintf (stderr,
+             "File descriptor too large for select (%d > %d)\n",
+             dev->fd_raw, FD_SETSIZE);
+    close (dev->fd_raw);
+    return 1;
+  }
 
   /* mac80211 stack detection */
-  ret = snprintf(strbuf, 
-                 sizeof(strbuf),
-                 "/sys/class/net/%s/phy80211/subsystem", 
-                 iface);
-  if ( (ret < 0) ||
-       (ret >= sizeof (strbuf)) ||
-       (0 != stat(strbuf, &sbuf)) )
-    {
-      fprintf(stderr, 
-              "Did not find 802.11 interface `%s'. Exiting.\n",
-              iface);
-      close (dev->fd_raw);
-      return 1;
-    }
-  strncpy(dev->iface, iface, IFNAMSIZ);
-  if (0 != openraw(dev))
-    {
-      close(dev->fd_raw);
-      return 1;
-    }
+  ret = snprintf (strbuf,
+                  sizeof (strbuf),
+                  "/sys/class/net/%s/phy80211/subsystem", iface);
+  if ((ret < 0) || (ret >= sizeof (strbuf)) || (0 != stat (strbuf, &sbuf)))
+  {
+    fprintf (stderr, "Did not find 802.11 interface `%s'. Exiting.\n", iface);
+    close (dev->fd_raw);
+    return 1;
+  }
+  strncpy (dev->iface, iface, IFNAMSIZ);
+  if (0 != openraw (dev))
+  {
+    close (dev->fd_raw);
+    return 1;
+  }
   return 0;
 }
 
@@ -555,14 +529,14 @@ wlaninit (struct Hardware_Infos *dev,
  * @return 0 if mac belongs to us, 1 if mac is for another target
  */
 static int
-mac_test (const struct ieee80211_frame *u8aIeeeHeader, 
-          const struct Hardware_Infos *dev)
+mac_test (const struct ieee80211_frame *u8aIeeeHeader,
+          const struct Hardware_Infos *dev)
 {
-  if (0 != memcmp(u8aIeeeHeader->i_addr3, &mac_bssid, MAC_ADDR_SIZE))
+  if (0 != memcmp (u8aIeeeHeader->i_addr3, &mac_bssid, MAC_ADDR_SIZE))
     return 1;
-  if (0 == memcmp(u8aIeeeHeader->i_addr1, dev->pl_mac, MAC_ADDR_SIZE))
+  if (0 == memcmp (u8aIeeeHeader->i_addr1, dev->pl_mac, MAC_ADDR_SIZE))
     return 0;
-  if (0 == memcmp(u8aIeeeHeader->i_addr1, &bc_all_mac, MAC_ADDR_SIZE))
+  if (0 == memcmp (u8aIeeeHeader->i_addr1, &bc_all_mac, MAC_ADDR_SIZE))
     return 0;
   return 1;
 }
@@ -574,17 +548,13 @@ mac_test (const struct ieee80211_frame *u8aIeeeHeader,
  * @param dev pointer to the Hardware_Infos struct
  */
 static void
-mac_set (struct ieee80211_frame *u8aIeeeHeader, 
-         const struct Hardware_Infos * dev)
+mac_set (struct ieee80211_frame *u8aIeeeHeader,
+         const struct Hardware_Infos *dev)
 {
   u8aIeeeHeader->i_fc[0] = 0x08;
   u8aIeeeHeader->i_fc[1] = 0x00;
-  memcpy(u8aIeeeHeader->i_addr2, 
-         dev->pl_mac, 
-         MAC_ADDR_SIZE);
-  memcpy(u8aIeeeHeader->i_addr3, 
-         &mac_bssid, 
-         MAC_ADDR_SIZE);
+  memcpy (u8aIeeeHeader->i_addr2, dev->pl_mac, MAC_ADDR_SIZE);
+  memcpy (u8aIeeeHeader->i_addr3, &mac_bssid, MAC_ADDR_SIZE);
 
 }
 
@@ -597,138 +567,140 @@ struct RadioTapheader
 };
 
 static void
-stdin_send_hw (void *cls, 
-               void *client, 
-               const struct GNUNET_MessageHeader *hdr)
+stdin_send_hw (void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
 {
-  struct Hardware_Infos * dev = cls;
+  struct Hardware_Infos *dev = cls;
   struct sendbuf *write_pout = &dev->write_pout;
-  struct Radiotap_Send * header = (struct Radiotap_Send *) &hdr[1];
-  struct ieee80211_frame * wlanheader;
+  struct Radiotap_Send *header = (struct Radiotap_Send *) &hdr[1];
+  struct ieee80211_frame *wlanheader;
   size_t sendsize;
 
   // struct? // FIXME: make nice...
   struct RadioTapheader rtheader;
+
   rtheader.header.it_version = 0;
-  rtheader.header.it_len = htole16(0x0c);
-  rtheader.header.it_present = htole32(0x00008004);
+  rtheader.header.it_len = htole16 (0x0c);
+  rtheader.header.it_present = htole32 (0x00008004);
   rtheader.rate = 0x00;
-  rtheader.txflags = htole16(IEEE80211_RADIOTAP_F_TX_NOACK | IEEE80211_RADIOTAP_F_TX_NOSEQ);
+  rtheader.txflags =
+      htole16 (IEEE80211_RADIOTAP_F_TX_NOACK | IEEE80211_RADIOTAP_F_TX_NOSEQ);
 
   /*  { 0x00, 0x00, <-- radiotap version
-      0x0c, 0x00, <- radiotap header length
-      0x04, 0x80, 0x00, 0x00,  <-- bitmap
-      0x00,  <-- rate
-      0x00,  <-- padding for natural alignment
-      0x18, 0x00,  <-- TX flags
-    };*/
-
-  sendsize = ntohs(hdr->size);
-  if (sendsize < sizeof(struct Radiotap_Send) + sizeof(struct GNUNET_MessageHeader))
-    {
-      fprintf(stderr, 
-              "Function stdin_send_hw: mailformed packet (too small)\n");
-      exit (1);
-    }
-  sendsize -= sizeof(struct Radiotap_Send) + sizeof(struct GNUNET_MessageHeader);
+   * 0x0c, 0x00, <- radiotap header length
+   * 0x04, 0x80, 0x00, 0x00,  <-- bitmap
+   * 0x00,  <-- rate
+   * 0x00,  <-- padding for natural alignment
+   * 0x18, 0x00,  <-- TX flags
+   * }; */
+
+  sendsize = ntohs (hdr->size);
+  if (sendsize <
+      sizeof (struct Radiotap_Send) + sizeof (struct GNUNET_MessageHeader))
+  {
+    fprintf (stderr, "Function stdin_send_hw: mailformed packet (too small)\n");
+    exit (1);
+  }
+  sendsize -=
+      sizeof (struct Radiotap_Send) + sizeof (struct GNUNET_MessageHeader);
 
   if (MAXLINE < sendsize)
-    {
-      fprintf(stderr, 
-              "Function stdin_send_hw: Packet too big for buffer\n");
-      exit(1);
-    }
-  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type))
-    {
-      fprintf(stderr, "Function stdin_send: wrong packet type\n");
-      exit(1);
-    }
-
-  rtheader.header.it_len = htole16(sizeof(rtheader));
+  {
+    fprintf (stderr, "Function stdin_send_hw: Packet too big for buffer\n");
+    exit (1);
+  }
+  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs (hdr->type))
+  {
+    fprintf (stderr, "Function stdin_send: wrong packet type\n");
+    exit (1);
+  }
+
+  rtheader.header.it_len = htole16 (sizeof (rtheader));
   rtheader.rate = header->rate;
-  memcpy(write_pout->buf, &rtheader, sizeof(rtheader));
-  memcpy(write_pout->buf + sizeof(rtheader), &header[1], sendsize);
+  memcpy (write_pout->buf, &rtheader, sizeof (rtheader));
+  memcpy (write_pout->buf + sizeof (rtheader), &header[1], sendsize);
   /* payload contains MAC address, but we don't trust it, so we'll 
-     overwrite it with OUR MAC address again to prevent mischief */
-  wlanheader = (struct ieee80211_frame *) (write_pout->buf + sizeof(rtheader));
-  mac_set(wlanheader, dev);
-  write_pout->size = sendsize + sizeof(rtheader);
+   * overwrite it with OUR MAC address again to prevent mischief */
+  wlanheader = (struct ieee80211_frame *) (write_pout->buf + sizeof (rtheader));
+  mac_set (wlanheader, dev);
+  write_pout->size = sendsize + sizeof (rtheader);
 }
 
 #if 0
 static int
-maketest(unsigned char * buf, struct Hardware_Infos * dev)
+maketest (unsigned char *buf, struct Hardware_Infos *dev)
 {
-  uint16_t * tmp16;
+  uint16_t *tmp16;
   static uint16_t seqenz = 0;
   static int first = 0;
 
   const int rate = 11000000;
   static const char
       txt[] =
-          "Hallo1Hallo2 Hallo3 Hallo4...998877665544332211Hallo1Hallo2 Hallo3 Hallo4...998877665544332211";
-
-  unsigned char u8aRadiotap[] =
-    { 0x00, 0x00, // <-- radiotap version
-        0x00, 0x00, // <- radiotap header length
-        0x04, 0x80, 0x02, 0x00, // <-- bitmap
-        0x00, // <-- rate
-        0x00, // <-- padding for natural alignment
-        0x10, 0x00, // <-- TX flags
-        0x04 //retries
-      };
+      "Hallo1Hallo2 Hallo3 Hallo4...998877665544332211Hallo1Hallo2 Hallo3 Hallo4...998877665544332211";
+
+  unsigned char u8aRadiotap[] = { 0x00, 0x00,   // <-- radiotap version
+    0x00, 0x00,                 // <- radiotap header length
+    0x04, 0x80, 0x02, 0x00,     // <-- bitmap
+    0x00,                       // <-- rate
+    0x00,                       // <-- padding for natural alignment
+    0x10, 0x00,                 // <-- TX flags
+    0x04                        //retries
+  };
 
   /*uint8_t u8aRadiotap[] =
-   {
-   0x00, 0x00, // <-- radiotap version
-   0x19, 0x00, // <- radiotap header length
-   0x6f, 0x08, 0x00, 0x00, // <-- bitmap
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // <-- timestamp
-   0x00, // <-- flags (Offset +0x10)
-   0x6c, // <-- rate (0ffset +0x11)
-   0x71, 0x09, 0xc0, 0x00, // <-- channel
-   0xde, // <-- antsignal
-   0x00, // <-- antnoise
-   0x01, // <-- antenna
-   };*/
+   * {
+   * 0x00, 0x00, // <-- radiotap version
+   * 0x19, 0x00, // <- radiotap header length
+   * 0x6f, 0x08, 0x00, 0x00, // <-- bitmap
+   * 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // <-- timestamp
+   * 0x00, // <-- flags (Offset +0x10)
+   * 0x6c, // <-- rate (0ffset +0x11)
+   * 0x71, 0x09, 0xc0, 0x00, // <-- channel
+   * 0xde, // <-- antsignal
+   * 0x00, // <-- antnoise
+   * 0x01, // <-- antenna
+   * }; */
 
   u8aRadiotap[8] = (rate / 500000);
-  u8aRadiotap[2] = htole16(sizeof(u8aRadiotap));
+  u8aRadiotap[2] = htole16 (sizeof (u8aRadiotap));
 
   static struct ieee80211_frame u8aIeeeHeader;
 
-  uint8_t u8aIeeeHeader_def[] =
-    { 0x08, 0x00, // Frame Control 0x08= 00001000 -> | b1,2 = 0 -> Version 0;
-        //      b3,4 = 10 -> Data; b5-8 = 0 -> Normal Data
-        //      0x01 = 00000001 -> | b1 = 1 to DS; b2 = 0 not from DS;
-        0x00, 0x00, // Duration/ID
-
-        //0x00, 0x1f, 0x3f, 0xd1, 0x8e, 0xe6, // mac1 - in this case receiver
-        0x00, 0x1d, 0xe0, 0xb0, 0x17, 0xdf, // mac1 - in this case receiver
-        0xC0, 0x3F, 0x0E, 0x44, 0x2D, 0x51, // mac2 - in this case sender
-        //0x02, 0x1d, 0xe0, 0x00, 0x01, 0xc4,
-        0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac3 - in this case bssid
-        0x10, 0x86, //Sequence Control
-      };
+  uint8_t u8aIeeeHeader_def[] = { 0x08, 0x00,   // Frame Control 0x08= 00001000 -> | b1,2 = 0 -> Version 0;
+    //      b3,4 = 10 -> Data; b5-8 = 0 -> Normal Data
+    //      0x01 = 00000001 -> | b1 = 1 to DS; b2 = 0 not from DS;
+    0x00, 0x00,                 // Duration/ID
+
+    //0x00, 0x1f, 0x3f, 0xd1, 0x8e, 0xe6, // mac1 - in this case receiver
+    0x00, 0x1d, 0xe0, 0xb0, 0x17, 0xdf, // mac1 - in this case receiver
+    0xC0, 0x3F, 0x0E, 0x44, 0x2D, 0x51, // mac2 - in this case sender
+    //0x02, 0x1d, 0xe0, 0x00, 0x01, 0xc4,
+    0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac3 - in this case bssid
+    0x10, 0x86,                 //Sequence Control
+  };
   if (0 == first)
-    {
-      memcpy(&u8aIeeeHeader, u8aIeeeHeader_def, sizeof(struct ieee80211_frame));
-      memcpy(u8aIeeeHeader.i_addr2, dev->pl_mac, MAC_ADDR_SIZE);
-      first = 1;
-    }
+  {
+    memcpy (&u8aIeeeHeader, u8aIeeeHeader_def, sizeof (struct ieee80211_frame));
+    memcpy (u8aIeeeHeader.i_addr2, dev->pl_mac, MAC_ADDR_SIZE);
+    first = 1;
+  }
 
-  tmp16 = (uint16_t*) u8aIeeeHeader.i_dur;
+  tmp16 = (uint16_t *) u8aIeeeHeader.i_dur;
   *tmp16
-      = (uint16_t) htole16((sizeof(txt) + sizeof(struct ieee80211_frame) * 1000000) / rate + 290);
-  tmp16 = (uint16_t*) u8aIeeeHeader.i_seq;
-  *tmp16 = (*tmp16 & IEEE80211_SEQ_FRAG_MASK) | (htole16(seqenz)
-      << IEEE80211_SEQ_SEQ_SHIFT);
+      =
+      (uint16_t)
+      htole16 ((sizeof (txt) +
+                sizeof (struct ieee80211_frame) * 1000000) / rate + 290);
+  tmp16 = (uint16_t *) u8aIeeeHeader.i_seq;
+  *tmp16 = (*tmp16 & IEEE80211_SEQ_FRAG_MASK) | (htole16 (seqenz)
+                                                 << IEEE80211_SEQ_SEQ_SHIFT);
   seqenz++;
 
-  memcpy(buf, u8aRadiotap, sizeof(u8aRadiotap));
-  memcpy(buf + sizeof(u8aRadiotap), &u8aIeeeHeader, sizeof(u8aIeeeHeader));
-  memcpy(buf + sizeof(u8aRadiotap) + sizeof(u8aIeeeHeader), txt, sizeof(txt));
-  return sizeof(u8aRadiotap) + sizeof(u8aIeeeHeader) + sizeof(txt);
+  memcpy (buf, u8aRadiotap, sizeof (u8aRadiotap));
+  memcpy (buf + sizeof (u8aRadiotap), &u8aIeeeHeader, sizeof (u8aIeeeHeader));
+  memcpy (buf + sizeof (u8aRadiotap) + sizeof (u8aIeeeHeader), txt,
+          sizeof (txt));
+  return sizeof (u8aRadiotap) + sizeof (u8aIeeeHeader) + sizeof (txt);
 
 }
 #endif
@@ -742,21 +714,20 @@ maketest(unsigned char * buf, struct Hardware_Infos * dev)
  */
 // FIXME: use 'struct MacAddress' for 'mac' (everywhere in this file)
 static int
-send_mac_to_plugin(char * buffer, uint8_t * mac)
+send_mac_to_plugin (char *buffer, uint8_t * mac)
 {
   struct Wlan_Helper_Control_Message macmsg;
 
-  macmsg.hdr.size = htons(sizeof(struct Wlan_Helper_Control_Message));
-  macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
-  memcpy(macmsg.mac.mac, mac, sizeof(struct MacAddress));
-  memcpy(buffer, &macmsg, sizeof(struct Wlan_Helper_Control_Message));
-  return sizeof(struct Wlan_Helper_Control_Message);
+  macmsg.hdr.size = htons (sizeof (struct Wlan_Helper_Control_Message));
+  macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
+  memcpy (macmsg.mac.mac, mac, sizeof (struct MacAddress));
+  memcpy (buffer, &macmsg, sizeof (struct Wlan_Helper_Control_Message));
+  return sizeof (struct Wlan_Helper_Control_Message);
 }
 
 
 static int
-hardwaremode (int argc, 
-              char *argv[])
+hardwaremode (int argc, char *argv[])
 {
   uid_t uid;
   struct Hardware_Infos dev;
@@ -768,18 +739,16 @@ hardwaremode (int argc,
   fd_set wfds;
   int retval;
   int stdin_open;
-  struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst;
+  struct GNUNET_SERVER_MessageStreamTokenizer *stdin_mst;
 
-  if (0 != wlaninit(&dev, argv[1]))
-    return 1;    
-  uid = getuid();
-  if (0 != setresuid(uid, uid, uid))
-    {
-      fprintf(stderr, 
-              "Failed to setresuid: %s\n",
-              strerror(errno));
-      /* not critical, continue anyway */
-    }
+  if (0 != wlaninit (&dev, argv[1]))
+    return 1;
+  uid = getuid ();
+  if (0 != setresuid (uid, uid, uid))
+  {
+    fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
+    /* not critical, continue anyway */
+  }
 
   dev.write_pout.size = 0;
   dev.write_pout.pos = 0;
@@ -787,162 +756,148 @@ hardwaremode (int argc,
 
   /* send mac to STDOUT first */
   write_std.pos = 0;
-  write_std.size = send_mac_to_plugin((char *) &write_std.buf, dev.pl_mac);
+  write_std.size = send_mac_to_plugin ((char *) &write_std.buf, dev.pl_mac);
   stdin_open = 1;
 
   while (1)
+  {
+    maxfd = -1;
+    FD_ZERO (&rfds);
+    if ((0 == dev.write_pout.size) && (1 == stdin_open))
     {
-      maxfd = -1;
-      FD_ZERO (&rfds);
-      if ( (0 == dev.write_pout.size) &&
-           (1 == stdin_open) )
-        {
-          FD_SET (STDIN_FILENO, &rfds);
-          maxfd = MAX (maxfd, STDIN_FILENO);
-        }
-      if (0 == write_std.size)
-        {
-          FD_SET (dev.fd_raw, &rfds);
-          maxfd = MAX(maxfd, dev.fd_raw);
-        }
-      FD_ZERO(&wfds);
-      if (0 < write_std.size)
-        {
-          FD_SET (STDOUT_FILENO, &wfds);
-          maxfd = MAX(maxfd, STDOUT_FILENO);
-        }
-      if (0 < dev.write_pout.size)
-        {
-          FD_SET(dev.fd_raw, &wfds);
-          maxfd = MAX(maxfd, dev.fd_raw);
-        }
-      retval = select(maxfd + 1, &rfds, &wfds, NULL, NULL);
-      if ( (-1 == retval) && 
-           (EINTR == errno) )        
-        continue;        
-      if (0 > retval)
-        {
-          fprintf(stderr, 
-                  "select failed: %s\n", 
-                  strerror(errno));
-          break;
-        }
+      FD_SET (STDIN_FILENO, &rfds);
+      maxfd = MAX (maxfd, STDIN_FILENO);
+    }
+    if (0 == write_std.size)
+    {
+      FD_SET (dev.fd_raw, &rfds);
+      maxfd = MAX (maxfd, dev.fd_raw);
+    }
+    FD_ZERO (&wfds);
+    if (0 < write_std.size)
+    {
+      FD_SET (STDOUT_FILENO, &wfds);
+      maxfd = MAX (maxfd, STDOUT_FILENO);
+    }
+    if (0 < dev.write_pout.size)
+    {
+      FD_SET (dev.fd_raw, &wfds);
+      maxfd = MAX (maxfd, dev.fd_raw);
+    }
+    retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL);
+    if ((-1 == retval) && (EINTR == errno))
+      continue;
+    if (0 > retval)
+    {
+      fprintf (stderr, "select failed: %s\n", strerror (errno));
+      break;
+    }
 
-      if (FD_ISSET(STDOUT_FILENO, &wfds))
-        {
-          ret = write(STDOUT_FILENO, 
-                      write_std.buf + write_std.pos,
-                      write_std.size - write_std.pos);
-          if (0 > ret)
-            {
-              fprintf (stderr, 
-                       "Failed to write to STDOUT: %s\n",
-                       strerror (errno));
-              break;
-            }
-          write_std.pos += ret;
-          if (write_std.pos == write_std.size)
-            {
-              write_std.pos = 0;
-              write_std.size = 0;
-            }
-        }        
-
-      if (FD_ISSET(dev.fd_raw, &wfds))
-        {
-          ret = write (dev.fd_raw, 
-                       dev.write_pout.buf, 
-                       dev.write_pout.size);
-          if (0 > ret)
-            {
-              fprintf (stderr, 
-                       "Line %u: Failed to write to WLAN device: %s, Message-Size: %u\n",__LINE__,
-                       strerror (errno), dev.write_pout.size);
-              break;
-            }
-          dev.write_pout.pos += ret;
-          if ( (dev.write_pout.pos != dev.write_pout.size) && 
-               (ret != 0) )
-            {
-              fprintf(stderr,
-                      "Line %u: Write error, partial send: %u/%u\n",__LINE__,
-                      dev.write_pout.pos, dev.write_pout.size);
-              break;
-            }
-          if (dev.write_pout.pos == dev.write_pout.size)
-            {
-              dev.write_pout.pos = 0;
-              dev.write_pout.size = 0;
-            }
-        }
+    if (FD_ISSET (STDOUT_FILENO, &wfds))
+    {
+      ret = write (STDOUT_FILENO,
+                   write_std.buf + write_std.pos,
+                   write_std.size - write_std.pos);
+      if (0 > ret)
+      {
+        fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno));
+        break;
+      }
+      write_std.pos += ret;
+      if (write_std.pos == write_std.size)
+      {
+        write_std.pos = 0;
+        write_std.size = 0;
+      }
+    }
 
-      if (FD_ISSET(STDIN_FILENO, &rfds))
-        {
-          ret = read(STDIN_FILENO, readbuf, sizeof(readbuf));
-          if (0 > ret)
-            {
-              fprintf(stderr, 
-                      "Read error from STDIN: %s\n",
-                      strerror (errno));
-              break;
-            }
-          if (0 == ret)
-            {
-              /* stop reading... */
-              stdin_open = 0;
-            }
-          GNUNET_SERVER_mst_receive (stdin_mst, NULL, 
-                                     readbuf, ret,
-                                     GNUNET_NO, GNUNET_NO);
-        }
+    if (FD_ISSET (dev.fd_raw, &wfds))
+    {
+      ret = write (dev.fd_raw, dev.write_pout.buf, dev.write_pout.size);
+      if (0 > ret)
+      {
+        fprintf (stderr,
+                 "Line %u: Failed to write to WLAN device: %s, Message-Size: %u\n",
+                 __LINE__, strerror (errno), dev.write_pout.size);
+        break;
+      }
+      dev.write_pout.pos += ret;
+      if ((dev.write_pout.pos != dev.write_pout.size) && (ret != 0))
+      {
+        fprintf (stderr,
+                 "Line %u: Write error, partial send: %u/%u\n", __LINE__,
+                 dev.write_pout.pos, dev.write_pout.size);
+        break;
+      }
+      if (dev.write_pout.pos == dev.write_pout.size)
+      {
+        dev.write_pout.pos = 0;
+        dev.write_pout.size = 0;
+      }
+    }
 
-      if (FD_ISSET(dev.fd_raw, &rfds))
-        {
-          struct GNUNET_MessageHeader * header;
-          struct Radiotap_rx * rxinfo;
-          struct ieee80211_frame * datastart;
-
-          header = (struct GNUNET_MessageHeader *) write_std.buf;
-          rxinfo = (struct Radiotap_rx *) &header[1];
-          datastart = (struct ieee80211_frame *) &rxinfo[1];
-          ret = linux_read (&dev,
-                            (unsigned char *) datastart,
-                            sizeof(write_std.buf) - sizeof(struct Radiotap_rx) - sizeof(struct GNUNET_MessageHeader), 
-                            rxinfo);
-          if (0 > ret)
-            {
-              fprintf(stderr, 
-                      "Read error from raw socket: %s\n", 
-                      strerror(errno));
-              break;
-            }
-          if ( (0 < ret) &&
-               (0 == mac_test(datastart, &dev)) )
-            {
-              write_std.size = ret + sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_rx);
-              header->size = htons(write_std.size);
-              header->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
-            }
-        }
+    if (FD_ISSET (STDIN_FILENO, &rfds))
+    {
+      ret = read (STDIN_FILENO, readbuf, sizeof (readbuf));
+      if (0 > ret)
+      {
+        fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno));
+        break;
+      }
+      if (0 == ret)
+      {
+        /* stop reading... */
+        stdin_open = 0;
+      }
+      GNUNET_SERVER_mst_receive (stdin_mst, NULL,
+                                 readbuf, ret, GNUNET_NO, GNUNET_NO);
+    }
 
+    if (FD_ISSET (dev.fd_raw, &rfds))
+    {
+      struct GNUNET_MessageHeader *header;
+      struct Radiotap_rx *rxinfo;
+      struct ieee80211_frame *datastart;
+
+      header = (struct GNUNET_MessageHeader *) write_std.buf;
+      rxinfo = (struct Radiotap_rx *) &header[1];
+      datastart = (struct ieee80211_frame *) &rxinfo[1];
+      ret = linux_read (&dev,
+                        (unsigned char *) datastart,
+                        sizeof (write_std.buf) - sizeof (struct Radiotap_rx) -
+                        sizeof (struct GNUNET_MessageHeader), rxinfo);
+      if (0 > ret)
+      {
+        fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno));
+        break;
+      }
+      if ((0 < ret) && (0 == mac_test (datastart, &dev)))
+      {
+        write_std.size =
+            ret + sizeof (struct GNUNET_MessageHeader) +
+            sizeof (struct Radiotap_rx);
+        header->size = htons (write_std.size);
+        header->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
+      }
     }
+
+  }
   /* Error handling, try to clean up a bit at least */
-  GNUNET_SERVER_mst_destroy(stdin_mst);
+  GNUNET_SERVER_mst_destroy (stdin_mst);
   close (dev.fd_raw);
-  return 1; 
+  return 1;
 }
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   if (2 != argc)
-    {
-      fprintf (stderr,
-               "This program must be started with the interface as argument.\nThis program was compiled at ----- %s ----\n", __TIMESTAMP__ );
-      fprintf (stderr,
-               "Usage: interface-name\n"
-               "\n");
-      return 1;
-    }
-  return hardwaremode(argc , argv);
+  {
+    fprintf (stderr,
+             "This program must be started with the interface as argument.\nThis program was compiled at ----- %s ----\n",
+             __TIMESTAMP__);
+    fprintf (stderr, "Usage: interface-name\n" "\n");
+    return 1;
+  }
+  return hardwaremode (argc, argv);
 }
diff --git a/src/transport/gnunet-transport-wlan-helper.h b/src/transport/gnunet-transport-wlan-helper.h
index 9cdff24e2..0c708f912 100644
--- a/src/transport/gnunet-transport-wlan-helper.h
+++ b/src/transport/gnunet-transport-wlan-helper.h
@@ -23,7 +23,7 @@
  * @brief common internal definitions for the wlan mediator
  * @author David Brodski
  */
- 
+
 #ifndef gnunet_wlan_H
 #define gnunet_wlan_H
 
@@ -72,4 +72,3 @@ struct sendbuf
 
 
 #endif /* gnunet_wlan_H */
-
diff --git a/src/transport/ieee80211_radiotap.h b/src/transport/ieee80211_radiotap.h
index 91d197995..ed1cd69dd 100644
--- a/src/transport/ieee80211_radiotap.h
+++ b/src/transport/ieee80211_radiotap.h
@@ -61,25 +61,26 @@
  * The radio capture header precedes the 802.11 header.
  * All data in the header is little endian on all platforms.
  */
-struct ieee80211_radiotap_header {
-        u8 it_version;          /* Version 0. Only increases
-                                 * for drastic changes,
-                                 * introduction of compatible
-                                 * new fields does not count.
-                                 */
-        u8 it_pad;
-        __le16 it_len;          /* length of the whole
-                                 * header in bytes, including
-                                 * it_version, it_pad,
-                                 * it_len, and data fields.
-                                 */
-        __le32 it_present;      /* A bitmap telling which
-                                 * fields are present. Set bit 31
-                                 * (0x80000000) to extend the
-                                 * bitmap by another 32 bits.
-                                 * Additional extensions are made
-                                 * by setting bit 31.
-                                 */
+struct ieee80211_radiotap_header
+{
+  u8 it_version;                /* Version 0. Only increases
+                                 * for drastic changes,
+                                 * introduction of compatible
+                                 * new fields does not count.
+                                 */
+  u8 it_pad;
+  __le16 it_len;                /* length of the whole
+                                 * header in bytes, including
+                                 * it_version, it_pad,
+                                 * it_len, and data fields.
+                                 */
+  __le32 it_present;            /* A bitmap telling which
+                                 * fields are present. Set bit 31
+                                 * (0x80000000) to extend the
+                                 * bitmap by another 32 bits.
+                                 * Additional extensions are made
+                                 * by setting bit 31.
+                                 */
 } __packed;
 
 /* Name                                 Data type    Units
@@ -179,71 +180,72 @@ struct ieee80211_radiotap_header {
  *     Number of unicast retries a transmitted frame used.
  *
  */
-enum ieee80211_radiotap_type {
-        IEEE80211_RADIOTAP_TSFT = 0,
-        IEEE80211_RADIOTAP_FLAGS = 1,
-        IEEE80211_RADIOTAP_RATE = 2,
-        IEEE80211_RADIOTAP_CHANNEL = 3,
-        IEEE80211_RADIOTAP_FHSS = 4,
-        IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
-        IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
-        IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
-        IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
-        IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
-        IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
-        IEEE80211_RADIOTAP_ANTENNA = 11,
-        IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
-        IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
-        IEEE80211_RADIOTAP_RX_FLAGS = 14,
-        IEEE80211_RADIOTAP_TX_FLAGS = 15,
-        IEEE80211_RADIOTAP_RTS_RETRIES = 16,
-        IEEE80211_RADIOTAP_DATA_RETRIES = 17,
+enum ieee80211_radiotap_type
+{
+  IEEE80211_RADIOTAP_TSFT = 0,
+  IEEE80211_RADIOTAP_FLAGS = 1,
+  IEEE80211_RADIOTAP_RATE = 2,
+  IEEE80211_RADIOTAP_CHANNEL = 3,
+  IEEE80211_RADIOTAP_FHSS = 4,
+  IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
+  IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
+  IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
+  IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
+  IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
+  IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
+  IEEE80211_RADIOTAP_ANTENNA = 11,
+  IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
+  IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
+  IEEE80211_RADIOTAP_RX_FLAGS = 14,
+  IEEE80211_RADIOTAP_TX_FLAGS = 15,
+  IEEE80211_RADIOTAP_RTS_RETRIES = 16,
+  IEEE80211_RADIOTAP_DATA_RETRIES = 17,
 
-        /* valid in every it_present bitmap, even vendor namespaces */
-        IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE = 29,
-        IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
-        IEEE80211_RADIOTAP_EXT = 31
+  /* valid in every it_present bitmap, even vendor namespaces */
+  IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE = 29,
+  IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
+  IEEE80211_RADIOTAP_EXT = 31
 };
 
 /* Channel flags. */
-#define IEEE80211_CHAN_TURBO    0x0010  /* Turbo channel */
-#define IEEE80211_CHAN_CCK      0x0020  /* CCK channel */
-#define IEEE80211_CHAN_OFDM     0x0040  /* OFDM channel */
-#define IEEE80211_CHAN_2GHZ     0x0080  /* 2 GHz spectrum channel. */
-#define IEEE80211_CHAN_5GHZ     0x0100  /* 5 GHz spectrum channel */
-#define IEEE80211_CHAN_PASSIVE  0x0200  /* Only passive scan allowed */
-#define IEEE80211_CHAN_DYN      0x0400  /* Dynamic CCK-OFDM channel */
-#define IEEE80211_CHAN_GFSK     0x0800  /* GFSK channel (FHSS PHY) */
+#define IEEE80211_CHAN_TURBO    0x0010  /* Turbo channel */
+#define IEEE80211_CHAN_CCK      0x0020  /* CCK channel */
+#define IEEE80211_CHAN_OFDM     0x0040  /* OFDM channel */
+#define IEEE80211_CHAN_2GHZ     0x0080  /* 2 GHz spectrum channel. */
+#define IEEE80211_CHAN_5GHZ     0x0100  /* 5 GHz spectrum channel */
+#define IEEE80211_CHAN_PASSIVE  0x0200  /* Only passive scan allowed */
+#define IEEE80211_CHAN_DYN      0x0400  /* Dynamic CCK-OFDM channel */
+#define IEEE80211_CHAN_GFSK     0x0800  /* GFSK channel (FHSS PHY) */
 
 /* For IEEE80211_RADIOTAP_FLAGS */
-#define IEEE80211_RADIOTAP_F_CFP        0x01    /* sent/received
-                                                 * during CFP
-                                                 */
-#define IEEE80211_RADIOTAP_F_SHORTPRE   0x02    /* sent/received
-                                                 * with short
-                                                 * preamble
-                                                 */
-#define IEEE80211_RADIOTAP_F_WEP        0x04    /* sent/received
-                                                 * with WEP encryption
-                                                 */
-#define IEEE80211_RADIOTAP_F_FRAG       0x08    /* sent/received
-                                                 * with fragmentation
-                                                 */
-#define IEEE80211_RADIOTAP_F_FCS        0x10    /* frame includes FCS */
-#define IEEE80211_RADIOTAP_F_DATAPAD    0x20    /* frame has padding between
-                                                 * 802.11 header and payload
-                                                 * (to 32-bit boundary)
-                                                 */
-#define IEEE80211_RADIOTAP_F_BADFCS     0x40    /* bad FCS */
+#define IEEE80211_RADIOTAP_F_CFP        0x01    /* sent/received
+                                                 * during CFP
+                                                 */
+#define IEEE80211_RADIOTAP_F_SHORTPRE   0x02    /* sent/received
+                                                 * with short
+                                                 * preamble
+                                                 */
+#define IEEE80211_RADIOTAP_F_WEP        0x04    /* sent/received
+                                                 * with WEP encryption
+                                                 */
+#define IEEE80211_RADIOTAP_F_FRAG       0x08    /* sent/received
+                                                 * with fragmentation
+                                                 */
+#define IEEE80211_RADIOTAP_F_FCS        0x10    /* frame includes FCS */
+#define IEEE80211_RADIOTAP_F_DATAPAD    0x20    /* frame has padding between
+                                                 * 802.11 header and payload
+                                                 * (to 32-bit boundary)
+                                                 */
+#define IEEE80211_RADIOTAP_F_BADFCS     0x40    /* bad FCS */
 
 /* For IEEE80211_RADIOTAP_RX_FLAGS */
-#define IEEE80211_RADIOTAP_F_RX_BADPLCP 0x0002  /* frame has bad PLCP */
+#define IEEE80211_RADIOTAP_F_RX_BADPLCP 0x0002  /* frame has bad PLCP */
 
 /* For IEEE80211_RADIOTAP_TX_FLAGS */
-#define IEEE80211_RADIOTAP_F_TX_FAIL    0x0001  /* failed due to excessive
-                                                 * retries */
-#define IEEE80211_RADIOTAP_F_TX_CTS     0x0002  /* used cts 'protection' */
-#define IEEE80211_RADIOTAP_F_TX_RTS     0x0004  /* used rts/cts handshake */
+#define IEEE80211_RADIOTAP_F_TX_FAIL    0x0001  /* failed due to excessive
+                                                 * retries */
+#define IEEE80211_RADIOTAP_F_TX_CTS     0x0002  /* used cts 'protection' */
+#define IEEE80211_RADIOTAP_F_TX_RTS     0x0004  /* used rts/cts handshake */
 
 /* Ugly macro to convert literal channel numbers into their mhz equivalents
  * There are certianly some conditions that will break this (like feeding it '30')
@@ -254,18 +256,20 @@ enum ieee80211_radiotap_type {
         ((x) + 1000) * 5)
 
 /* helpers */
-static inline u16 get_unaligned_le16(const u8 *p)
+static inline u16
+get_unaligned_le16 (const u8 *p)
 {
   return p[0] | p[1] << 8;
 }
 
 
-static inline int ieee80211_get_radiotap_len(unsigned char *data)
+static inline int
+ieee80211_get_radiotap_len (unsigned char *data)
 {
-        struct ieee80211_radiotap_header *hdr =
-                (struct ieee80211_radiotap_header *)data;
+  struct ieee80211_radiotap_header *hdr =
+      (struct ieee80211_radiotap_header *) data;
 
-        return get_unaligned_le16( (const u8 *) &hdr->it_len);
+  return get_unaligned_le16 ((const u8 *) &hdr->it_len);
 }
 
-#endif                          /* IEEE80211_RADIOTAP_H */
+#endif /* IEEE80211_RADIOTAP_H */
diff --git a/src/transport/perf_transport_ats.c b/src/transport/perf_transport_ats.c
index 3f8950a8a..df1ebe950 100644
--- a/src/transport/perf_transport_ats.c
+++ b/src/transport/perf_transport_ats.c
@@ -40,48 +40,51 @@ static uint64_t sim_with_opt_avg;
 static uint64_t mlp_no_opt_avg;
 static uint64_t mlp_with_opt_avg;
 
-static glp_prob * prob;
+static glp_prob *prob;
 
 static struct GNUNET_TIME_Absolute start;
 static struct GNUNET_TIME_Absolute end;
 
-static void 
-solve_mlp(int presolve)
+static void
+solve_mlp (int presolve)
 {
   int result, solution;
   glp_iocp opt_mlp;
 
-  glp_init_iocp(&opt_mlp);
+  glp_init_iocp (&opt_mlp);
   opt_mlp.msg_lev = GLP_MSG_OFF;
   opt_mlp.presolve = GLP_OFF;
 
   result = glp_intopt (prob, &opt_mlp);
-  solution =  glp_mip_status (prob);
-  GNUNET_assert ((solution == 5) && (result==0));
+  solution = glp_mip_status (prob);
+  GNUNET_assert ((solution == 5) && (result == 0));
 }
 
 static void
-solve_lp(int presolve)
+solve_lp (int presolve)
 {
   int result;
   int solution;
 
   glp_smcp opt_lp;
-  glp_init_smcp(&opt_lp);
 
-  opt_lp.msg_lev = GLP_MSG_OFF;
-  if (presolve==GNUNET_YES) opt_lp.presolve = GLP_ON;
-  else opt_lp.presolve = GLP_OFF;
+  glp_init_smcp (&opt_lp);
 
-  result = glp_simplex(prob, &opt_lp);
-  solution =  glp_get_status (prob);
-  GNUNET_assert ((solution == 5) && (result==0));
+  opt_lp.msg_lev = GLP_MSG_OFF;
+  if (presolve == GNUNET_YES)
+    opt_lp.presolve = GLP_ON;
+  else
+    opt_lp.presolve = GLP_OFF;
+
+  result = glp_simplex (prob, &opt_lp);
+  solution = glp_get_status (prob);
+  GNUNET_assert ((solution == 5) && (result == 0));
 }
 
 #if 0
 /* Modify quality constraint */
-static void 
-modify_qm(int start, int length, int values_to_change)
+static void
+modify_qm (int start, int length, int values_to_change)
 {
   //int * ind = GNUNET_malloc (length * sizeof (int));
   //double *val = GNUNET_malloc (length * sizeof (double));
@@ -89,15 +92,16 @@ modify_qm(int start, int length, int values_to_change)
   double val[1000];
 
   int res = 0;
-  int c = start, c2=1;
-  while (c<=(start+values_to_change))
+  int c = start, c2 = 1;
+
+  while (c <= (start + values_to_change))
   {
-    res = glp_get_mat_row(prob, c, ind, val);
+    res = glp_get_mat_row (prob, c, ind, val);
 
-    printf("%i %i \n", c, res);
-    for (c2=0; c2<res; c2++)
+    printf ("%i %i \n", c, res);
+    for (c2 = 0; c2 < res; c2++)
     {
-            printf("%i = %f \n", ind[c2], val[c2]);
+      printf ("%i = %f \n", ind[c2], val[c2]);
     }
     c++;
   }
@@ -107,162 +111,158 @@ modify_qm(int start, int length, int values_to_change)
 
 
 
-static void 
-bench_simplex_optimization(char * file, int executions)
+static void
+bench_simplex_optimization (char *file, int executions)
 {
   int c;
   int res;
 
-  prob = glp_create_prob();
-  res = glp_read_lp(prob, NULL, file);
+  prob = glp_create_prob ();
+  res = glp_read_lp (prob, NULL, file);
   if (res != 0)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-        "Problem file `%s' not found\n",  file);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
     ret = 1;
     return;
   }
 
-  solve_lp(GNUNET_YES);
+  solve_lp (GNUNET_YES);
 
-  for (c=0; c<executions;c++)
+  for (c = 0; c < executions; c++)
   {
-    start = GNUNET_TIME_absolute_get();
-    solve_lp(GNUNET_NO);
-    end = GNUNET_TIME_absolute_get();
+    start = GNUNET_TIME_absolute_get ();
+    solve_lp (GNUNET_NO);
+    end = GNUNET_TIME_absolute_get ();
 
-    exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value;
+    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;
 
     sim_with_opt_avg += exec_time[c];
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-        "Simplex /w optimization iterations %i: %llu \n",  c, exec_time[c]);
+                "Simplex /w optimization iterations %i: %llu \n", c,
+                exec_time[c]);
   }
 
-  glp_delete_prob(prob);
+  glp_delete_prob (prob);
 }
 
 
 static void
-bench_simplex_no_optimization(char * file, int executions)
+bench_simplex_no_optimization (char *file, int executions)
 {
   int c;
   int res;
 
-  prob = glp_create_prob();
-  res = glp_read_lp(prob, NULL, file);
+  prob = glp_create_prob ();
+  res = glp_read_lp (prob, NULL, file);
   if (res != 0)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-        "Problem file `%s' not found\n",  file);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
     ret = 1;
     return;
   }
 
-  for (c=0; c<executions;c++)
+  for (c = 0; c < executions; c++)
   {
-    start = GNUNET_TIME_absolute_get();
-    solve_lp(GNUNET_YES);
-    end = GNUNET_TIME_absolute_get();
+    start = GNUNET_TIME_absolute_get ();
+    solve_lp (GNUNET_YES);
+    end = GNUNET_TIME_absolute_get ();
 
-    exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value;
+    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;
 
     sim_no_opt_avg += exec_time[c];
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-        "Simplex iterations %i: %llu \n",
-        c, exec_time[c]);
+                "Simplex iterations %i: %llu \n", c, exec_time[c]);
   }
 
-  glp_delete_prob(prob);
+  glp_delete_prob (prob);
 }
 
 static void
-bench_mlp_no_optimization(char * file, int executions)
+bench_mlp_no_optimization (char *file, int executions)
 {
   int c;
   int res;
 
-  prob = glp_create_prob();
-  res = glp_read_lp(prob, NULL, file);
+  prob = glp_create_prob ();
+  res = glp_read_lp (prob, NULL, file);
   if (res != 0)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-        "Problem file `%s' not found\n",  file);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
     ret = 1;
     return;
   }
-  for (c=0; c<executions;c++)
+  for (c = 0; c < executions; c++)
   {
-      start = GNUNET_TIME_absolute_get();
-      solve_lp(GNUNET_YES);
-      solve_mlp (GNUNET_NO);
-      end = GNUNET_TIME_absolute_get();
+    start = GNUNET_TIME_absolute_get ();
+    solve_lp (GNUNET_YES);
+    solve_mlp (GNUNET_NO);
+    end = GNUNET_TIME_absolute_get ();
 
-      exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value;
+    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;
 
-      mlp_no_opt_avg += exec_time[c];
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-          "MLP iterations no optimization %i: %llu \n",
-          c, exec_time[c]);
+    mlp_no_opt_avg += exec_time[c];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MLP iterations no optimization %i: %llu \n", c, exec_time[c]);
   }
 
-  glp_delete_prob(prob);
+  glp_delete_prob (prob);
 }
 
 
-static void 
-bench_mlp_with_optimization(char * file, int executions, int changes)
+static void
+bench_mlp_with_optimization (char *file, int executions, int changes)
 {
   int c;
   int res;
 
-  prob = glp_create_prob();
-  res = glp_read_lp(prob, NULL, file);
+  prob = glp_create_prob ();
+  res = glp_read_lp (prob, NULL, file);
   if (res != 0)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-        "Problem file `%s' not found\n",  file);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
     ret = 1;
     return;
   }
 
-  solve_lp(GNUNET_YES);
+  solve_lp (GNUNET_YES);
 
-  for (c=0; c<executions;c++)
+  for (c = 0; c < executions; c++)
   {
-    start = GNUNET_TIME_absolute_get();
+    start = GNUNET_TIME_absolute_get ();
     //modify_qm(906, 0, 0);
-    solve_lp(GNUNET_NO);
+    solve_lp (GNUNET_NO);
     solve_mlp (GNUNET_NO);
-    end = GNUNET_TIME_absolute_get();
+    end = GNUNET_TIME_absolute_get ();
 
-    exec_time[c] = GNUNET_TIME_absolute_get_difference(start, end).rel_value;
+    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;
 
     mlp_with_opt_avg += exec_time[c];
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-        "MLP /w optimization iterations %i: %llu \n",
-        c, exec_time[c]);
+                "MLP /w optimization iterations %i: %llu \n", c, exec_time[c]);
   }
 
-  glp_delete_prob(prob);
+  glp_delete_prob (prob);
 }
 
 #if 0
-void modify_cr (int start, int length, int count)
+void
+modify_cr (int start, int length, int count)
 {
   //int * ind = GNUNET_malloc (length * sizeof (int));
   //double *val = GNUNET_malloc (length * sizeof (double));
   int ind[500];
   double val[500];
   int res = 0;
-  int c = start, c2=1;
-  while (c<=(start+count))
+  int c = start, c2 = 1;
+
+  while (c <= (start + count))
   {
-    res = glp_get_mat_row(prob, c, ind, val);
+    res = glp_get_mat_row (prob, c, ind, val);
 
-    printf("row index: %i non-zero elements: %i \n", c, res);
-    for (c2=1; c2<=res; c2++)
+    printf ("row index: %i non-zero elements: %i \n", c, res);
+    for (c2 = 1; c2 <= res; c2++)
     {
-            printf("%i = %f ", ind[c2], val[c2]);
+      printf ("%i = %f ", ind[c2], val[c2]);
     }
     c++;
     printf ("\n----\n");
@@ -272,7 +272,8 @@ void modify_cr (int start, int length, int count)
 #endif
 
 
-int main (int argc, char *argv[])
+int
+main (int argc, char *argv[])
 {
 
   GNUNET_log_setup ("perf-transport-ats",
@@ -283,6 +284,7 @@ int main (int argc, char *argv[])
 #endif
                     NULL);
   int nullfd = OPEN ("/dev/null", O_RDWR | O_APPEND);
+
   if (nullfd < 0)
     return GNUNET_SYSERR;
   if (dup2 (nullfd, 1) < 0)
@@ -293,7 +295,7 @@ int main (int argc, char *argv[])
   }
 
 
-  char * file = "ats_mlp_p100_m400.problem";
+  char *file = "ats_mlp_p100_m400.problem";
 
   bench_simplex_no_optimization (file, executions);
   bench_simplex_optimization (file, executions);
@@ -305,33 +307,32 @@ int main (int argc, char *argv[])
 
   // -> 400 addresses
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-      "Simplex, no optimization, average per address: %f\n",
-      ((double) sim_no_opt_avg / EXECS) / 400);
-  GAUGER ("TRANSPORT","GLPK simplex  no optimization",
-      ((double) sim_no_opt_avg  / EXECS) / 400, "ms/address");
+              "Simplex, no optimization, average per address: %f\n",
+              ((double) sim_no_opt_avg / EXECS) / 400);
+  GAUGER ("TRANSPORT", "GLPK simplex  no optimization",
+          ((double) sim_no_opt_avg / EXECS) / 400, "ms/address");
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-      "Simplex, with optimization, average per address: %f\n",
-      ((double) sim_with_opt_avg / EXECS) / 400);
+              "Simplex, with optimization, average per address: %f\n",
+              ((double) sim_with_opt_avg / EXECS) / 400);
   GAUGER ("TRANSPORT",
-      "GLPK simplex, 100 peers 400 addresses with optimization",
-      ((double) sim_with_opt_avg  / EXECS) / 400, "ms/address");
+          "GLPK simplex, 100 peers 400 addresses with optimization",
+          ((double) sim_with_opt_avg / EXECS) / 400, "ms/address");
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-      "MLP no optimization average per address: %f\n",
-      ((double) mlp_no_opt_avg  / EXECS) / 400);
-  GAUGER ("TRANSPORT","GLPK MLP 100 peers 400 addresses no optimization",
-      ((double) mlp_no_opt_avg  / EXECS) / 400, "ms/address");
+              "MLP no optimization average per address: %f\n",
+              ((double) mlp_no_opt_avg / EXECS) / 400);
+  GAUGER ("TRANSPORT", "GLPK MLP 100 peers 400 addresses no optimization",
+          ((double) mlp_no_opt_avg / EXECS) / 400, "ms/address");
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-      "MLP optimization average per address: %f\n",
-      ((double) mlp_with_opt_avg/ EXECS) / 400);
+              "MLP optimization average per address: %f\n",
+              ((double) mlp_with_opt_avg / EXECS) / 400);
   GAUGER ("TRANSPORT",
-      "GLPK MLP 100 peers 400 addresses with optimization",
-      ((double) mlp_with_opt_avg  / EXECS) / 400, "ms/address");
+          "GLPK MLP 100 peers 400 addresses with optimization",
+          ((double) mlp_with_opt_avg / EXECS) / 400, "ms/address");
   (void) CLOSE (nullfd);
   return ret;
 }
 
 /* end of perf_transport_ats.c*/
-
diff --git a/src/transport/plugin_transport_http.c b/src/transport/plugin_transport_http.c
index e63549784..0c856e4ab 100644
--- a/src/transport/plugin_transport_http.c
+++ b/src/transport/plugin_transport_http.c
@@ -114,14 +114,14 @@ struct IPv4HttpAddressWrapper
   /**
    * Linked list next
    */
-  struct IPv4HttpAddressWrapper * next;
+  struct IPv4HttpAddressWrapper *next;
 
   /**
    * Linked list previous
    */
-  struct IPv4HttpAddressWrapper * prev;
+  struct IPv4HttpAddressWrapper *prev;
 
-  struct IPv4HttpAddress * addr;
+  struct IPv4HttpAddress *addr;
 };
 
 /**
@@ -149,14 +149,14 @@ struct IPv6HttpAddressWrapper
   /**
    * Linked list next
    */
-  struct IPv6HttpAddressWrapper * next;
+  struct IPv6HttpAddressWrapper *next;
 
   /**
    * Linked list previous
    */
-  struct IPv6HttpAddressWrapper * prev;
+  struct IPv6HttpAddressWrapper *prev;
 
-  struct IPv6HttpAddress * addr;
+  struct IPv6HttpAddress *addr;
 };
 
 /**
@@ -167,12 +167,12 @@ struct HTTP_Message
   /**
    * next pointer for double linked list
    */
-  struct HTTP_Message * next;
+  struct HTTP_Message *next;
 
   /**
    * previous pointer for double linked list
    */
-  struct HTTP_Message * prev;
+  struct HTTP_Message *prev;
 
   /**
    * buffer containing data to send
@@ -219,13 +219,13 @@ struct HTTP_PeerContext
    * Linked list of connections with this peer
    * head
    */
-  struct Session * head;
+  struct Session *head;
 
   /**
    * Linked list of connections with this peer
    * tail
    */
-  struct Session * tail;
+  struct Session *tail;
 
   /**
    * id for next session
@@ -235,7 +235,7 @@ struct HTTP_PeerContext
   /**
    * Last session used to send data
    */
-  struct Session * last_session;
+  struct Session *last_session;
 
   /**
    * The task resetting inbound quota delay
@@ -259,17 +259,17 @@ struct Session
   /**
    * next session in linked list
    */
-  struct Session * next;
+  struct Session *next;
 
   /**
    * previous session in linked list
    */
-  struct Session * prev;
+  struct Session *prev;
 
   /**
    * address of this session
    */
-  void * addr;
+  void *addr;
 
   /**
    * address length
@@ -279,24 +279,24 @@ struct Session
   /**
    * target url
    */
-  char * url;
+  char *url;
 
   /**
    * Message queue for outbound messages
    * head of queue
    */
-  struct HTTP_Message * pending_msgs_head;
+  struct HTTP_Message *pending_msgs_head;
 
   /**
    * Message queue for outbound messages
    * tail of queue
    */
-  struct HTTP_Message * pending_msgs_tail;
+  struct HTTP_Message *pending_msgs_tail;
 
   /**
    * partner peer this connection belongs to
    */
-  struct HTTP_PeerContext * peercontext;
+  struct HTTP_PeerContext *peercontext;
 
   /**
    * message stream tokenizer for incoming data
@@ -352,14 +352,14 @@ struct Session
    * outbound session: CURL *
    * inbound session: mhd_connection *
    */
-  void * send_endpoint;
+  void *send_endpoint;
 
   /**
    * entity managing recieving data
    * outbound session: CURL *
    * inbound session: mhd_connection *
    */
-  void * recv_endpoint;
+  void *recv_endpoint;
 
   /**
    * Current queue size
@@ -423,7 +423,7 @@ struct Plugin
   /**
    * cURL Multihandle
    */
-  CURLM * multi_handle;
+  CURLM *multi_handle;
 
   /**
    * Our handle to the NAT module.
@@ -433,22 +433,22 @@ struct Plugin
   /**
    * ipv4 DLL head
    */
-  struct IPv4HttpAddressWrapper * ipv4_addr_head;
+  struct IPv4HttpAddressWrapper *ipv4_addr_head;
 
   /**
    * ipv4 DLL tail
    */
-  struct IPv4HttpAddressWrapper * ipv4_addr_tail;
+  struct IPv4HttpAddressWrapper *ipv4_addr_tail;
 
   /**
    * ipv6 DLL head
    */
-  struct IPv6HttpAddressWrapper * ipv6_addr_head;
+  struct IPv6HttpAddressWrapper *ipv6_addr_head;
 
   /**
    * ipv6 DLL tail
    */
-  struct IPv6HttpAddressWrapper * ipv6_addr_tail;
+  struct IPv6HttpAddressWrapper *ipv6_addr_tail;
 
   /**
    * Our ASCII encoded, hashed peer identity
@@ -459,17 +459,17 @@ struct Plugin
   /**
    * IPv4 Address the plugin binds to
    */
-  struct sockaddr_in * bind4_address;
+  struct sockaddr_in *bind4_address;
 
   /**
    * IPv6 Address the plugins binds to
    */
-  struct sockaddr_in6 * bind6_address;
+  struct sockaddr_in6 *bind6_address;
 
   /**
    * Hostname to bind to
    */
-  char * bind_hostname;
+  char *bind_hostname;
 
   /**
    * Is IPv4 enabled?
@@ -499,18 +499,18 @@ struct Plugin
   /**
    * Closure passed by MHD to the mhd_logger function
    */
-  void * mhd_log;
+  void *mhd_log;
 
   /* only needed for HTTPS plugin */
 #if BUILD_HTTPS
   /* The certificate MHD uses as an \0 terminated string */
-  char * cert;
+  char *cert;
 
   /* The private key MHD uses as an \0 terminated string */
-  char * key;
+  char *key;
 
   /* crypto init string */
-  char * crypto_init;
+  char *crypto_init;
 #endif
 };
 
@@ -547,22 +547,25 @@ struct PrettyPrinterContext
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-http_plugin_address_to_string (void *cls,
-                                   const void *addr,
-                                   size_t addrlen);
+static const char *http_plugin_address_to_string (void *cls,
+                                                  const void *addr,
+                                                  size_t addrlen);
 
 
 /**
  * Call MHD to process pending ipv4 requests and then go back
  * and schedule the next run.
  */
-static void http_server_daemon_v4_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+static void http_server_daemon_v4_run (void *cls,
+                                       const struct GNUNET_SCHEDULER_TaskContext
+                                       *tc);
 /**
  * Call MHD to process pending ipv6 requests and then go back
  * and schedule the next run.
  */
-static void http_server_daemon_v6_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+static void http_server_daemon_v6_run (void *cls,
+                                       const struct GNUNET_SCHEDULER_TaskContext
+                                       *tc);
 
 /**
  * Function setting up curl handle and selecting message to send
@@ -586,12 +589,13 @@ static int curl_schedule (struct Plugin *plugin);
  * @param cls plugin as closure
  * @param tc task context
  */
-static void reset_inbound_quota_delay (void *cls,
-                                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+reset_inbound_quota_delay (void *cls,
+                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct HTTP_PeerContext * pc = cls;
-  
-  GNUNET_assert(cls != NULL);
+  struct HTTP_PeerContext *pc = cls;
+
+  GNUNET_assert (cls != NULL);
   pc->reset_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
@@ -607,18 +611,16 @@ static void reset_inbound_quota_delay (void *cls,
  * @param id session id
  * @return the created url
  */
-static char * 
-create_url(struct Plugin *plugin, 
-           const void * addr, size_t addrlen, 
-           size_t id)
+static char *
+create_url (struct Plugin *plugin, const void *addr, size_t addrlen, size_t id)
 {
   char *url = NULL;
-  char *addr_str = (char *) http_plugin_address_to_string(NULL, addr, addrlen);
+  char *addr_str = (char *) http_plugin_address_to_string (NULL, addr, addrlen);
 
-  GNUNET_assert ((addr!=NULL) && (addrlen != 0));
-  GNUNET_asprintf(&url,
-                  "%s://%s/%s;%u", PROTOCOL_PREFIX, addr_str,
-                  (char *) (&plugin->my_ascii_hash_ident),id);
+  GNUNET_assert ((addr != NULL) && (addrlen != 0));
+  GNUNET_asprintf (&url,
+                   "%s://%s/%s;%u", PROTOCOL_PREFIX, addr_str,
+                   (char *) (&plugin->my_ascii_hash_ident), id);
   return url;
 }
 
@@ -629,14 +631,12 @@ create_url(struct Plugin *plugin,
  * @param msg message
  * @return GNUNET_SYSERR if msg not found, GNUNET_OK on success
  */
-static int 
-remove_http_message (struct Session * ps, 
-                     struct HTTP_Message * msg)
+static int
+remove_http_message (struct Session *ps, struct HTTP_Message *msg)
 {
-  GNUNET_CONTAINER_DLL_remove(ps->pending_msgs_head,
-                              ps->pending_msgs_tail,
-                              msg);
-  GNUNET_free(msg);
+  GNUNET_CONTAINER_DLL_remove (ps->pending_msgs_head,
+                               ps->pending_msgs_tail, msg);
+  GNUNET_free (msg);
   return GNUNET_OK;
 }
 
@@ -647,59 +647,56 @@ remove_http_message (struct Session * ps,
  * @param value the peer context
  * @return GNUNET_YES on success
  */
-static int 
+static int
 remove_peer_context_Iterator (void *cls,
-                              const GNUNET_HashCode *key, 
-                              void *value)
+                              const GNUNET_HashCode * key, void *value)
 {
   struct Plugin *plugin = cls;
-  struct HTTP_PeerContext * pc = value;
-  struct Session * ps = pc->head;
-  struct Session * tmp = NULL;
-  struct HTTP_Message * msg = NULL;
-  struct HTTP_Message * msg_tmp = NULL;
+  struct HTTP_PeerContext *pc = value;
+  struct Session *ps = pc->head;
+  struct Session *tmp = NULL;
+  struct HTTP_Message *msg = NULL;
+  struct HTTP_Message *msg_tmp = NULL;
 
 #if DEBUG_HTTP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Freeing context for peer `%s'\n",
-              GNUNET_i2s(&pc->identity));
+              "Freeing context for peer `%s'\n", GNUNET_i2s (&pc->identity));
 #endif
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (plugin->peers, 
-                                                       &pc->identity.hashPubKey, 
-                                                       pc));
-  while (ps!=NULL)
+                 GNUNET_CONTAINER_multihashmap_remove (plugin->peers,
+                                                       &pc->identity.hashPubKey,
+                                                       pc));
+  while (ps != NULL)
+  {
+    plugin->env->session_end (plugin, &pc->identity, ps);
+    tmp = ps->next;
+
+    GNUNET_free_non_null (ps->addr);
+    GNUNET_free (ps->url);
+    if (ps->msgtok != NULL)
+      GNUNET_SERVER_mst_destroy (ps->msgtok);
+
+    msg = ps->pending_msgs_head;
+    while (msg != NULL)
     {
-      plugin->env->session_end(plugin, &pc->identity, ps);
-      tmp = ps->next;
-      
-      GNUNET_free_non_null (ps->addr);
-      GNUNET_free(ps->url);
-      if (ps->msgtok != NULL)
-        GNUNET_SERVER_mst_destroy (ps->msgtok);
-      
-      msg = ps->pending_msgs_head;
-      while (msg!=NULL)
-        {
-          msg_tmp = msg->next;
-          GNUNET_free(msg);
-          msg = msg_tmp;
-        }
-      if (ps->direction==OUTBOUND)
-        {
-          if (ps->send_endpoint!=NULL)
-            curl_easy_cleanup(ps->send_endpoint);
-          if (ps->recv_endpoint!=NULL)
-            curl_easy_cleanup(ps->recv_endpoint);
-        }      
-      GNUNET_free(ps);
-      ps=tmp;
+      msg_tmp = msg->next;
+      GNUNET_free (msg);
+      msg = msg_tmp;
+    }
+    if (ps->direction == OUTBOUND)
+    {
+      if (ps->send_endpoint != NULL)
+        curl_easy_cleanup (ps->send_endpoint);
+      if (ps->recv_endpoint != NULL)
+        curl_easy_cleanup (ps->recv_endpoint);
     }
-  GNUNET_free(pc);
+    GNUNET_free (ps);
+    ps = tmp;
+  }
+  GNUNET_free (pc);
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# HTTP peers active"),
-                            -1,
-                            GNUNET_NO);
+                            gettext_noop ("# HTTP peers active"),
+                            -1, GNUNET_NO);
   return GNUNET_YES;
 }
 
@@ -712,115 +709,114 @@ remove_peer_context_Iterator (void *cls,
  * @param call_msg_cont_result result to call message continuations with
  * @return GNUNET_SYSERR if msg not found, GNUNET_OK on success
  */
-static int 
-remove_session (struct HTTP_PeerContext * pc, 
-                struct Session * ps,  
-                int call_msg_cont, 
-                int call_msg_cont_result)
+static int
+remove_session (struct HTTP_PeerContext *pc,
+                struct Session *ps, int call_msg_cont, int call_msg_cont_result)
 {
-  struct HTTP_Message * msg;
-  struct Plugin * plugin = ps->peercontext->plugin;
+  struct HTTP_Message *msg;
+  struct Plugin *plugin = ps->peercontext->plugin;
 
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connection %X: removing %s session %X with id %u\n", 
-              ps,
-              (ps->direction == INBOUND) 
-              ? "inbound" 
-              : "outbound", 
-              ps, ps->session_id);
-#endif
-  plugin->env->session_end(plugin, &pc->identity, ps);
+              "Connection %X: removing %s session %X with id %u\n",
+              ps,
+              (ps->direction == INBOUND)
+              ? "inbound" : "outbound", ps, ps->session_id);
+#endif
+  plugin->env->session_end (plugin, &pc->identity, ps);
   GNUNET_free_non_null (ps->addr);
   GNUNET_SERVER_mst_destroy (ps->msgtok);
-  GNUNET_free(ps->url);
-  if (ps->direction==INBOUND)
+  GNUNET_free (ps->url);
+  if (ps->direction == INBOUND)
+  {
+    if (ps->recv_endpoint != NULL)
     {
-      if (ps->recv_endpoint != NULL)
-        {
-          curl_easy_cleanup(ps->recv_endpoint);
-          ps->recv_endpoint = NULL;
-        }
-      if (ps->send_endpoint != NULL)
-        {
-          curl_easy_cleanup(ps->send_endpoint);
-          ps->send_endpoint = NULL;
-        }
+      curl_easy_cleanup (ps->recv_endpoint);
+      ps->recv_endpoint = NULL;
+    }
+    if (ps->send_endpoint != NULL)
+    {
+      curl_easy_cleanup (ps->send_endpoint);
+      ps->send_endpoint = NULL;
     }
-  
+  }
+
   msg = ps->pending_msgs_head;
-  while (msg!=NULL)
+  while (msg != NULL)
+  {
+    if ((call_msg_cont == GNUNET_YES) && (msg->transmit_cont != NULL))
     {
-      if ((call_msg_cont == GNUNET_YES) && (msg->transmit_cont!=NULL))
-        {
-          msg->transmit_cont (msg->transmit_cont_cls,
-                              &pc->identity,
-                              call_msg_cont_result);
-        }
-      GNUNET_CONTAINER_DLL_remove(ps->pending_msgs_head,
-                                  ps->pending_msgs_head,
-                                  msg);
-      GNUNET_free(msg);
-      msg = ps->pending_msgs_head;
+      msg->transmit_cont (msg->transmit_cont_cls,
+                          &pc->identity, call_msg_cont_result);
     }
-  
-  GNUNET_CONTAINER_DLL_remove(pc->head,pc->tail,ps);
-  GNUNET_free(ps);
+    GNUNET_CONTAINER_DLL_remove (ps->pending_msgs_head,
+                                 ps->pending_msgs_head, msg);
+    GNUNET_free (msg);
+    msg = ps->pending_msgs_head;
+  }
+
+  GNUNET_CONTAINER_DLL_remove (pc->head, pc->tail, ps);
+  GNUNET_free (ps);
   ps = NULL;
 
   /* no sessions left remove peer */
-  if (pc->head==NULL)
-    {
+  if (pc->head == NULL)
+  {
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No sessions left for peer `%s', removing context\n",
-                  GNUNET_i2s(&pc->identity));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No sessions left for peer `%s', removing context\n",
+                GNUNET_i2s (&pc->identity));
 #endif
-      remove_peer_context_Iterator(plugin, &pc->identity.hashPubKey, pc);
-    }
-  
+    remove_peer_context_Iterator (plugin, &pc->identity.hashPubKey, pc);
+  }
+
   return GNUNET_OK;
 }
 
 
 #if 0
-static int check_localaddress (const struct sockaddr *addr, socklen_t addrlen)
+static int
+check_localaddress (const struct sockaddr *addr, socklen_t addrlen)
 {
-        uint32_t res = 0;
-        int local = GNUNET_NO;
-        int af = addr->sa_family;
-    switch (af)
-    {
-      case AF_INET:
-      {
-          uint32_t netmask = 0x7F000000;
-          uint32_t address = ntohl (((struct sockaddr_in *) addr)->sin_addr.s_addr);
-          res = (address >> 24) ^ (netmask >> 24);
-          if (res != 0)
-                  local = GNUNET_NO;
-          else
-                  local = GNUNET_YES;
+  uint32_t res = 0;
+  int local = GNUNET_NO;
+  int af = addr->sa_family;
+
+  switch (af)
+  {
+  case AF_INET:
+  {
+    uint32_t netmask = 0x7F000000;
+    uint32_t address = ntohl (((struct sockaddr_in *) addr)->sin_addr.s_addr);
+
+    res = (address >> 24) ^ (netmask >> 24);
+    if (res != 0)
+      local = GNUNET_NO;
+    else
+      local = GNUNET_YES;
 #if DEBUG_HTTP
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Checking IPv4 address `%s': %s\n", GNUNET_a2s (addr, addrlen), (local==GNUNET_YES) ? "local" : "global");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Checking IPv4 address `%s': %s\n", GNUNET_a2s (addr, addrlen),
+                (local == GNUNET_YES) ? "local" : "global");
 #endif
-            break;
-      }
-      case AF_INET6:
-      {
-           if (IN6_IS_ADDR_LOOPBACK  (&((struct sockaddr_in6 *) addr)->sin6_addr) ||
-                   IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *) addr)->sin6_addr))
-                   local = GNUNET_YES;
-           else
-                   local = GNUNET_NO;
+    break;
+  }
+  case AF_INET6:
+  {
+    if (IN6_IS_ADDR_LOOPBACK (&((struct sockaddr_in6 *) addr)->sin6_addr) ||
+        IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *) addr)->sin6_addr))
+      local = GNUNET_YES;
+    else
+      local = GNUNET_NO;
 #if DEBUG_HTTP
-           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Checking IPv6 address `%s' : %s\n", GNUNET_a2s (addr, addrlen), (local==GNUNET_YES) ? "local" : "global");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Checking IPv6 address `%s' : %s\n", GNUNET_a2s (addr, addrlen),
+                (local == GNUNET_YES) ? "local" : "global");
 #endif
-           break;
-      }
-    }
-        return local;
+    break;
+  }
+  }
+  return local;
 }
 
 
@@ -842,99 +838,103 @@ process_interfaces (void *cls,
                     const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
-  struct IPv4HttpAddress * t4;
-  struct IPv6HttpAddress * t6;
+  struct IPv4HttpAddress *t4;
+  struct IPv6HttpAddress *t6;
   int af;
 
   if (plugin->use_localaddresses == GNUNET_NO)
   {
-          if (GNUNET_YES == check_localaddress (addr, addrlen))
-          {
+    if (GNUNET_YES == check_localaddress (addr, addrlen))
+    {
 #if DEBUG_HTTP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                   PROTOCOL_PREFIX,
-                           "Not notifying transport of address `%s' (local address)\n",
-                           GNUNET_a2s (addr, addrlen));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                       PROTOCOL_PREFIX,
+                       "Not notifying transport of address `%s' (local address)\n",
+                       GNUNET_a2s (addr, addrlen));
 #endif
-                  return GNUNET_OK;
-          }
+      return GNUNET_OK;
+    }
   }
 
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
   af = addr->sa_family;
   if ((af == AF_INET) &&
-      (plugin->use_ipv4 == GNUNET_YES) &&
-      (plugin->bind6_address == NULL) ) {
+      (plugin->use_ipv4 == GNUNET_YES) && (plugin->bind6_address == NULL))
+  {
 
-          struct in_addr bnd_cmp = ((struct sockaddr_in *) addr)->sin_addr;
-      t4 = GNUNET_malloc(sizeof(struct IPv4HttpAddress));
-     // Not skipping loopback addresses
+    struct in_addr bnd_cmp = ((struct sockaddr_in *) addr)->sin_addr;
 
+    t4 = GNUNET_malloc (sizeof (struct IPv4HttpAddress));
+    // Not skipping loopback addresses
 
-      t4->ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
-      t4->port = htons (plugin->port_inbound);
-      if (plugin->bind4_address != NULL) {
-        if (0 == memcmp(&plugin->bind4_address->sin_addr, &bnd_cmp, sizeof (struct in_addr)))
-          {
-            GNUNET_CONTAINER_DLL_insert(plugin->ipv4_addr_head,
-                                        plugin->ipv4_addr_tail,t4);
-                  plugin->env->notify_address(plugin->env->cls,
-                                              GNUNET_YES,
-                                              t4, sizeof (struct IPv4HttpAddress));
-            return GNUNET_OK;
-          }
-        GNUNET_free (t4);
-        return GNUNET_OK;
+
+    t4->ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
+    t4->port = htons (plugin->port_inbound);
+    if (plugin->bind4_address != NULL)
+    {
+      if (0 ==
+          memcmp (&plugin->bind4_address->sin_addr, &bnd_cmp,
+                  sizeof (struct in_addr)))
+      {
+        GNUNET_CONTAINER_DLL_insert (plugin->ipv4_addr_head,
+                                     plugin->ipv4_addr_tail, t4);
+        plugin->env->notify_address (plugin->env->cls,
+                                     GNUNET_YES,
+                                     t4, sizeof (struct IPv4HttpAddress));
+        return GNUNET_OK;
       }
-      else
-          {
-          GNUNET_CONTAINER_DLL_insert (plugin->ipv4_addr_head,
-                                       plugin->ipv4_addr_tail,
-                                       t4);
-          plugin->env->notify_address(plugin->env->cls,
-                                      GNUNET_YES,
-                                      t4, sizeof (struct IPv4HttpAddress));
-          return GNUNET_OK;
-          }
-   }
-   if ((af == AF_INET6) &&
-            (plugin->use_ipv6 == GNUNET_YES) && 
-            (plugin->bind4_address == NULL) ) {
-
-          struct in6_addr bnd_cmp6 = ((struct sockaddr_in6 *) addr)->sin6_addr;
-
-      t6 = GNUNET_malloc(sizeof(struct IPv6HttpAddress));
-      GNUNET_assert(t6 != NULL);
-
-      if (plugin->bind6_address != NULL) {
-          if (0 == memcmp(&plugin->bind6_address->sin6_addr,
-                                                  &bnd_cmp6,
-                                                 sizeof (struct in6_addr))) {
-              memcpy (&t6->ipv6_addr,
-                      &((struct sockaddr_in6 *) addr)->sin6_addr,
-                      sizeof (struct in6_addr));
-              t6->port = htons (plugin->port_inbound);
-              plugin->env->notify_address(plugin->env->cls,
-                                          GNUNET_YES,
-                                          t6, sizeof (struct IPv6HttpAddress));
-              GNUNET_CONTAINER_DLL_insert(plugin->ipv6_addr_head,
-                                          plugin->ipv6_addr_tail,
-                                          t6);
-              return GNUNET_OK;
-              }
-          GNUNET_free (t6);
-          return GNUNET_OK;
-          }
-      memcpy (&t6->ipv6_addr,
-                  &((struct sockaddr_in6 *) addr)->sin6_addr,
-                  sizeof (struct in6_addr));
-      t6->port = htons (plugin->port_inbound);
-      GNUNET_CONTAINER_DLL_insert(plugin->ipv6_addr_head,plugin->ipv6_addr_tail,t6);
+      GNUNET_free (t4);
+      return GNUNET_OK;
+    }
+    else
+    {
+      GNUNET_CONTAINER_DLL_insert (plugin->ipv4_addr_head,
+                                   plugin->ipv4_addr_tail, t4);
+      plugin->env->notify_address (plugin->env->cls,
+                                   GNUNET_YES,
+                                   t4, sizeof (struct IPv4HttpAddress));
+      return GNUNET_OK;
+    }
+  }
+  if ((af == AF_INET6) &&
+      (plugin->use_ipv6 == GNUNET_YES) && (plugin->bind4_address == NULL))
+  {
 
-      plugin->env->notify_address(plugin->env->cls,
-                                  GNUNET_YES,
-                                  t6, sizeof (struct IPv6HttpAddress));
+    struct in6_addr bnd_cmp6 = ((struct sockaddr_in6 *) addr)->sin6_addr;
+
+    t6 = GNUNET_malloc (sizeof (struct IPv6HttpAddress));
+    GNUNET_assert (t6 != NULL);
+
+    if (plugin->bind6_address != NULL)
+    {
+      if (0 == memcmp (&plugin->bind6_address->sin6_addr,
+                       &bnd_cmp6, sizeof (struct in6_addr)))
+      {
+        memcpy (&t6->ipv6_addr,
+                &((struct sockaddr_in6 *) addr)->sin6_addr,
+                sizeof (struct in6_addr));
+        t6->port = htons (plugin->port_inbound);
+        plugin->env->notify_address (plugin->env->cls,
+                                     GNUNET_YES,
+                                     t6, sizeof (struct IPv6HttpAddress));
+        GNUNET_CONTAINER_DLL_insert (plugin->ipv6_addr_head,
+                                     plugin->ipv6_addr_tail, t6);
+        return GNUNET_OK;
+      }
+      GNUNET_free (t6);
+      return GNUNET_OK;
+    }
+    memcpy (&t6->ipv6_addr,
+            &((struct sockaddr_in6 *) addr)->sin6_addr,
+            sizeof (struct in6_addr));
+    t6->port = htons (plugin->port_inbound);
+    GNUNET_CONTAINER_DLL_insert (plugin->ipv6_addr_head, plugin->ipv6_addr_tail,
+                                 t6);
+
+    plugin->env->notify_address (plugin->env->cls,
+                                 GNUNET_YES,
+                                 t6, sizeof (struct IPv6HttpAddress));
   }
   return GNUNET_OK;
 }
@@ -946,69 +946,62 @@ process_interfaces (void *cls,
  * @param fmt format string
  * @param ap  list of arguments
  */
-static void 
-mhd_logger (void * arg, 
-            const char * fmt, 
-            va_list ap)
+static void
+mhd_logger (void *arg, const char *fmt, va_list ap)
 {
   char text[1024];
 
-  vsnprintf(text, sizeof(text), fmt, ap);
-  va_end(ap);
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "MHD: %s\n", 
-              text);
+  vsnprintf (text, sizeof (text), fmt, ap);
+  va_end (ap);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MHD: %s\n", text);
 }
 
 
-static void 
-mhd_termination_cb (void *cls, 
-                    struct MHD_Connection * connection, 
-                    void **httpSessionCache)
+static void
+mhd_termination_cb (void *cls,
+                    struct MHD_Connection *connection, void **httpSessionCache)
 {
-  struct Session * ps = *httpSessionCache;
+  struct Session *ps = *httpSessionCache;
+
   if (ps == NULL)
     return;
-  struct HTTP_PeerContext * pc = ps->peercontext;
+  struct HTTP_PeerContext *pc = ps->peercontext;
   struct Plugin *plugin = cls;
 
   GNUNET_assert (cls != NULL);
-    plugin->current_connections--;
+  plugin->current_connections--;
 
-  if (connection==ps->recv_endpoint)
-    {
+  if (connection == ps->recv_endpoint)
+  {
 #if DEBUG_CONNECTIONS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: inbound connection from peer `%s' was terminated\n", 
-                  ps, 
-                  GNUNET_i2s(&pc->identity));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: inbound connection from peer `%s' was terminated\n",
+                ps, GNUNET_i2s (&pc->identity));
 #endif
-      ps->recv_active = GNUNET_NO;
-      ps->recv_connected = GNUNET_NO;
-      ps->recv_endpoint = NULL;
-    }
-  if (connection==ps->send_endpoint)
-    {
-      ps->send_active = GNUNET_NO;
-      ps->send_connected = GNUNET_NO;
-      ps->send_endpoint = NULL;
+    ps->recv_active = GNUNET_NO;
+    ps->recv_connected = GNUNET_NO;
+    ps->recv_endpoint = NULL;
+  }
+  if (connection == ps->send_endpoint)
+  {
+    ps->send_active = GNUNET_NO;
+    ps->send_connected = GNUNET_NO;
+    ps->send_endpoint = NULL;
 #if DEBUG_CONNECTIONS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: outbound connection from peer `%s' was terminated\n",
-                  ps, 
-                  GNUNET_i2s(&pc->identity));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: outbound connection from peer `%s' was terminated\n",
+                ps, GNUNET_i2s (&pc->identity));
 #endif
-    }
+  }
 
   /* if both connections disconnected, remove session */
-  if ( (ps->send_connected == GNUNET_NO) && 
-       (ps->recv_connected == GNUNET_NO) )
+  if ((ps->send_connected == GNUNET_NO) && (ps->recv_connected == GNUNET_NO))
   {
     GNUNET_STATISTICS_update (pc->plugin->env->stats,
-                              gettext_noop ("# HTTP inbound sessions for peers active"),
-                              -1,
-                              GNUNET_NO);
-    remove_session(pc,ps,GNUNET_YES,GNUNET_SYSERR);
+                              gettext_noop
+                              ("# HTTP inbound sessions for peers active"), -1,
+                              GNUNET_NO);
+    remove_session (pc, ps, GNUNET_YES, GNUNET_SYSERR);
   }
 }
 
@@ -1019,54 +1012,52 @@ mhd_termination_cb (void *cls,
  * @param client clien
  * @param message the message to be forwarded to transport service
  */
-static void 
+static void
 mhd_write_mst_cb (void *cls,
-                  void *client,
-                  const struct GNUNET_MessageHeader *message)
+                  void *client, const struct GNUNET_MessageHeader *message)
 {
-  struct Session *ps  = cls; 
+  struct Session *ps = cls;
   struct HTTP_PeerContext *pc;
   struct GNUNET_TIME_Relative delay;
 
-  GNUNET_assert(ps != NULL);
+  GNUNET_assert (ps != NULL);
   pc = ps->peercontext;
-  GNUNET_assert(pc != NULL);
+  GNUNET_assert (pc != NULL);
 #if DEBUG_HTTP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connection %X: Forwarding message to transport service, type %u and size %u from `%s' (`%s')\n",
-              ps,
-              ntohs(message->type),
-              ntohs(message->size),
-              GNUNET_i2s(&(ps->peercontext)->identity),
-              http_plugin_address_to_string(NULL,ps->addr,ps->addrlen));
+              "Connection %X: Forwarding message to transport service, type %u and size %u from `%s' (`%s')\n",
+              ps,
+              ntohs (message->type),
+              ntohs (message->size),
+              GNUNET_i2s (&(ps->peercontext)->identity),
+              http_plugin_address_to_string (NULL, ps->addr, ps->addrlen));
 #endif
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
+
   distance[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
   distance[0].value = htonl (1);
   distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   distance[1].value = htonl (0);
   delay = pc->plugin->env->receive (ps->peercontext->plugin->env->cls,
-                                    &pc->identity,
-                                    message,
-                                    (const struct GNUNET_TRANSPORT_ATS_Information *) &distance,
-                                    2,
-                                    ps,
-                                    NULL,
-                                    0);
+                                    &pc->identity,
+                                    message,
+                                    (const struct
+                                     GNUNET_TRANSPORT_ATS_Information *)
+                                    &distance, 2, ps, NULL, 0);
   pc->delay = delay;
   if (pc->reset_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (pc->reset_task);
-  
+
   if (delay.rel_value > 0)
-    {
+  {
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: Inbound quota management: delay next read for %llu ms \n", 
-                  ps,
-                  delay.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: Inbound quota management: delay next read for %llu ms \n",
+                ps, delay.rel_value);
 #endif
-      pc->reset_task = GNUNET_SCHEDULER_add_delayed (delay, &reset_inbound_quota_delay, pc);
-    }
+    pc->reset_task =
+        GNUNET_SCHEDULER_add_delayed (delay, &reset_inbound_quota_delay, pc);
+  }
 }
 
 
@@ -1080,19 +1071,19 @@ mhd_write_mst_cb (void *cls,
  *
  */
 static int
-mhd_accept_cb (void *cls,
-               const struct sockaddr *addr, 
-               socklen_t addr_len)
+mhd_accept_cb (void *cls, const struct sockaddr *addr, socklen_t addr_len)
 {
   struct Plugin *plugin = cls;
+
   GNUNET_assert (cls != NULL);
 
   if (plugin->max_connect_per_transport > plugin->current_connections)
   {
-    plugin->current_connections ++;
+    plugin->current_connections++;
     return MHD_YES;
   }
-  else return MHD_NO;
+  else
+    return MHD_NO;
 }
 
 
@@ -1107,55 +1098,52 @@ mhd_accept_cb (void *cls,
 static ssize_t
 mhd_send_callback (void *cls, uint64_t pos, char *buf, size_t max)
 {
-  struct Session * ps = cls;
-  struct HTTP_PeerContext * pc;
-  struct HTTP_Message * msg;
+  struct Session *ps = cls;
+  struct HTTP_PeerContext *pc;
+  struct HTTP_Message *msg;
   int bytes_read = 0;
 
-  GNUNET_assert (ps!=NULL);
+  GNUNET_assert (ps != NULL);
 
   pc = ps->peercontext;
   msg = ps->pending_msgs_tail;
-  if (ps->send_force_disconnect==GNUNET_YES)
-    {
+  if (ps->send_force_disconnect == GNUNET_YES)
+  {
 #if DEBUG_CONNECTIONS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: outbound forced to disconnect\n",
-                  ps);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: outbound forced to disconnect\n", ps);
 #endif
-      return -1;
+    return -1;
+  }
+
+  if (msg != NULL)
+  {
+    /* sending */
+    if ((msg->size - msg->pos) <= max)
+    {
+      memcpy (buf, &msg->buf[msg->pos], (msg->size - msg->pos));
+      bytes_read = msg->size - msg->pos;
+      msg->pos += (msg->size - msg->pos);
     }
-  
-  if (msg!=NULL)
+    else
     {
-      /* sending */
-      if ((msg->size-msg->pos) <= max)
-        {
-          memcpy(buf,&msg->buf[msg->pos],(msg->size-msg->pos));
-          bytes_read = msg->size-msg->pos;
-          msg->pos+=(msg->size-msg->pos);
-        }
-      else
-        {
-          memcpy(buf,&msg->buf[msg->pos],max);
-          msg->pos+=max;
-          bytes_read = max;
-        }
-      
-      /* removing message */
-      if (msg->pos==msg->size)
-        {
-          if (NULL!=msg->transmit_cont)
-            msg->transmit_cont (msg->transmit_cont_cls,&pc->identity,GNUNET_OK);
-          ps->queue_length_cur -= msg->size;
-          remove_http_message(ps,msg);
-        }
+      memcpy (buf, &msg->buf[msg->pos], max);
+      msg->pos += max;
+      bytes_read = max;
     }
+
+    /* removing message */
+    if (msg->pos == msg->size)
+    {
+      if (NULL != msg->transmit_cont)
+        msg->transmit_cont (msg->transmit_cont_cls, &pc->identity, GNUNET_OK);
+      ps->queue_length_cur -= msg->size;
+      remove_http_message (ps, msg);
+    }
+  }
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connection %X: MHD has sent %u bytes\n", 
-              ps, 
-              bytes_read);
+              "Connection %X: MHD has sent %u bytes\n", ps, bytes_read);
 #endif
   return bytes_read;
 }
@@ -1170,21 +1158,20 @@ mhd_send_callback (void *cls, uint64_t pos, char *buf, size_t max)
  */
 static int
 mhd_access_cb (void *cls,
-               struct MHD_Connection *mhd_connection,
-               const char *url,
-               const char *method,
-               const char *version,
-               const char *upload_data,
-               size_t * upload_data_size,
-               void **httpSessionCache)
+               struct MHD_Connection *mhd_connection,
+               const char *url,
+               const char *method,
+               const char *version,
+               const char *upload_data,
+               size_t * upload_data_size, void **httpSessionCache)
 {
   struct Plugin *plugin = cls;
   struct MHD_Response *response;
-  const union MHD_ConnectionInfo * conn_info;
+  const union MHD_ConnectionInfo *conn_info;
   const struct sockaddr *client_addr;
-  const struct sockaddr_in  *addrin;
+  const struct sockaddr_in *addrin;
   const struct sockaddr_in6 *addrin6;
-  char address[INET6_ADDRSTRLEN+14];
+  char address[INET6_ADDRSTRLEN + 14];
   struct GNUNET_PeerIdentity pi_in;
   size_t id_num = 0;
   struct IPv4HttpAddress ipv4addr;
@@ -1193,251 +1180,259 @@ mhd_access_cb (void *cls,
   struct Session *ps = NULL;
   struct Session *ps_tmp = NULL;
   int res = GNUNET_NO;
-  void * addr = NULL;
-  size_t addr_len = 0 ;
+  void *addr = NULL;
+  size_t addr_len = 0;
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
 
   if (NULL == *httpSessionCache)
+  {
+    /* check url for peer identity , if invalid send HTTP 404 */
+    size_t len = strlen (&url[1]);
+    char *peer = GNUNET_malloc (104 + 1);
+
+    if ((len > 104) && (url[104] == ';'))
     {
-      /* check url for peer identity , if invalid send HTTP 404*/
-      size_t len = strlen(&url[1]);
-      char * peer = GNUNET_malloc(104+1);
-      
-      if ( (len>104) && (url[104]==';'))
-        {
-          char * id = GNUNET_malloc((len-104)+1);
-          strcpy(id,&url[105]);
-          memcpy(peer,&url[1],103);
-          peer[103] = '\0';
-        id_num = strtoul ( id, NULL , 10);
-        GNUNET_free(id);
+      char *id = GNUNET_malloc ((len - 104) + 1);
+
+      strcpy (id, &url[105]);
+      memcpy (peer, &url[1], 103);
+      peer[103] = '\0';
+      id_num = strtoul (id, NULL, 10);
+      GNUNET_free (id);
     }
     res = GNUNET_CRYPTO_hash_from_string (peer, &(pi_in.hashPubKey));
-    GNUNET_free(peer);
-    if ( GNUNET_SYSERR == res )
-      {
-        response = MHD_create_response_from_data (strlen (HTTP_ERROR_RESPONSE),
-                                                  HTTP_ERROR_RESPONSE,
-                                                  MHD_NO, MHD_NO);
-        res = MHD_queue_response (mhd_connection, MHD_HTTP_NOT_FOUND, response);
-        MHD_destroy_response (response);
+    GNUNET_free (peer);
+    if (GNUNET_SYSERR == res)
+    {
+      response = MHD_create_response_from_data (strlen (HTTP_ERROR_RESPONSE),
+                                                HTTP_ERROR_RESPONSE,
+                                                MHD_NO, MHD_NO);
+      res = MHD_queue_response (mhd_connection, MHD_HTTP_NOT_FOUND, response);
+      MHD_destroy_response (response);
 #if DEBUG_CONNECTIONS
       if (res == MHD_YES)
         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Peer has no valid ident, sent HTTP 1.1/404\n");
+                    "Peer has no valid ident, sent HTTP 1.1/404\n");
       else
         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Peer has no valid ident, could not send error\n");
+                    "Peer has no valid ident, could not send error\n");
 #endif
       return res;
-      }
     }
+  }
   else
+  {
+    ps = *httpSessionCache;
+    pc = ps->peercontext;
+  }
+
+  if (NULL == *httpSessionCache)
+  {
+    /* get peer context */
+    pc = GNUNET_CONTAINER_multihashmap_get (plugin->peers, &pi_in.hashPubKey);
+    /* Peer unknown */
+    if (pc == NULL)
     {
-      ps = *httpSessionCache;
-      pc = ps->peercontext;
+      pc = GNUNET_malloc (sizeof (struct HTTP_PeerContext));
+      pc->plugin = plugin;
+      pc->session_id_counter = 1;
+      pc->last_session = NULL;
+      memcpy (&pc->identity, &pi_in, sizeof (struct GNUNET_PeerIdentity));
+      GNUNET_CONTAINER_multihashmap_put (plugin->peers,
+                                         &pc->identity.hashPubKey,
+                                         pc,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+      GNUNET_STATISTICS_update (plugin->env->stats,
+                                gettext_noop ("# HTTP peers active"),
+                                1, GNUNET_NO);
+    }
+
+    conn_info =
+        MHD_get_connection_info (mhd_connection,
+                                 MHD_CONNECTION_INFO_CLIENT_ADDRESS);
+    /* Incoming IPv4 connection */
+    /* cast required for legacy MHD API < 0.9.6 */
+    client_addr = (const struct sockaddr *) conn_info->client_addr;
+    if (AF_INET == client_addr->sa_family)
+    {
+      addrin = (const struct sockaddr_in *) client_addr;
+      inet_ntop (addrin->sin_family, &(addrin->sin_addr), address,
+                 INET_ADDRSTRLEN);
+      memcpy (&ipv4addr.ipv4_addr, &(addrin->sin_addr),
+              sizeof (struct in_addr));
+      ipv4addr.port = addrin->sin_port;
+      addr = &ipv4addr;
+      addr_len = sizeof (struct IPv4HttpAddress);
+    }
+    /* Incoming IPv6 connection */
+    if (AF_INET6 == client_addr->sa_family)
+    {
+      addrin6 = (const struct sockaddr_in6 *) client_addr;
+      inet_ntop (addrin6->sin6_family, &(addrin6->sin6_addr), address,
+                 INET6_ADDRSTRLEN);
+      memcpy (&ipv6addr.ipv6_addr, &(addrin6->sin6_addr),
+              sizeof (struct in6_addr));
+      ipv6addr.port = addrin6->sin6_port;
+      addr = &ipv6addr;
+      addr_len = sizeof (struct IPv6HttpAddress);
     }
-  
-  if (NULL == *httpSessionCache)
+
+    GNUNET_assert (addr != NULL);
+    GNUNET_assert (addr_len != 0);
+
+    ps = NULL;
+    /* only inbound sessions here */
+
+    ps_tmp = pc->head;
+    while (ps_tmp != NULL)
     {
-      /* get peer context */
-      pc = GNUNET_CONTAINER_multihashmap_get (plugin->peers, &pi_in.hashPubKey);
-      /* Peer unknown */
-      if (pc==NULL)
-        {
-          pc = GNUNET_malloc(sizeof (struct HTTP_PeerContext));
-          pc->plugin = plugin;
-          pc->session_id_counter=1;
-          pc->last_session = NULL;
-          memcpy(&pc->identity, &pi_in, sizeof(struct GNUNET_PeerIdentity));
-          GNUNET_CONTAINER_multihashmap_put(plugin->peers, 
-                                            &pc->identity.hashPubKey,
-                                            pc, 
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
-          GNUNET_STATISTICS_update (plugin->env->stats,
-                                    gettext_noop ("# HTTP peers active"),
-                                    1,
-                                    GNUNET_NO);
-        }
-
-      conn_info = MHD_get_connection_info(mhd_connection, MHD_CONNECTION_INFO_CLIENT_ADDRESS );
-      /* Incoming IPv4 connection */
-      /* cast required for legacy MHD API < 0.9.6 */
-      client_addr = (const struct sockaddr *) conn_info->client_addr;
-      if ( AF_INET == client_addr->sa_family)
-        {
-          addrin = (const struct sockaddr_in*) client_addr;
-          inet_ntop(addrin->sin_family, &(addrin->sin_addr),address,INET_ADDRSTRLEN);
-          memcpy(&ipv4addr.ipv4_addr,&(addrin->sin_addr),sizeof(struct in_addr));
-          ipv4addr.port = addrin->sin_port;
-          addr = &ipv4addr;
-          addr_len = sizeof(struct IPv4HttpAddress);
-        }
-      /* Incoming IPv6 connection */
-      if ( AF_INET6 == client_addr->sa_family)
-        {
-          addrin6 = (const struct sockaddr_in6 *) client_addr;
-          inet_ntop(addrin6->sin6_family, &(addrin6->sin6_addr),address,INET6_ADDRSTRLEN);
-          memcpy(&ipv6addr.ipv6_addr,&(addrin6->sin6_addr),sizeof(struct in6_addr));
-          ipv6addr.port = addrin6->sin6_port;
-          addr = &ipv6addr;
-          addr_len = sizeof(struct IPv6HttpAddress);
-        }
-      
-      GNUNET_assert (addr != NULL);
-      GNUNET_assert (addr_len != 0);
-      
-      ps = NULL;
-      /* only inbound sessions here */
-      
-      ps_tmp = pc->head;
-      while (ps_tmp!=NULL)
-        {
-          if ((ps_tmp->direction==INBOUND) && (ps_tmp->session_id == id_num) && (id_num!=0))
-            {
-              if ((ps_tmp->recv_force_disconnect!=GNUNET_YES) && (ps_tmp->send_force_disconnect!=GNUNET_YES))
-                ps=ps_tmp;
-              break;
-            }
-          ps_tmp=ps_tmp->next;
-        }
-      
-      if (ps==NULL)
-        {
-          ps = GNUNET_malloc(sizeof (struct Session));
-          ps->addr = GNUNET_malloc(addr_len);
-          memcpy(ps->addr,addr,addr_len);
-          ps->addrlen = addr_len;
-          ps->direction=INBOUND;
-          ps->pending_msgs_head = NULL;
-          ps->pending_msgs_tail = NULL;
-          ps->send_connected=GNUNET_NO;
-          ps->send_active=GNUNET_NO;
-          ps->recv_connected=GNUNET_NO;
-          ps->recv_active=GNUNET_NO;
-          ps->peercontext=pc;
-          ps->session_id =id_num;
-          ps->queue_length_cur = 0;
-          ps->queue_length_max = GNUNET_SERVER_MAX_MESSAGE_SIZE;
-          ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
-          GNUNET_CONTAINER_DLL_insert(pc->head,pc->tail,ps);
-          GNUNET_STATISTICS_update (plugin->env->stats,
-                                    gettext_noop ("# HTTP inbound sessions for peers active"),
-                                    1,
-                                    GNUNET_NO);
-        }
-      
-      *httpSessionCache = ps;
-      if (ps->msgtok==NULL)
-        ps->msgtok = GNUNET_SERVER_mst_create (&mhd_write_mst_cb, ps);
+      if ((ps_tmp->direction == INBOUND) && (ps_tmp->session_id == id_num) &&
+          (id_num != 0))
+      {
+        if ((ps_tmp->recv_force_disconnect != GNUNET_YES) &&
+            (ps_tmp->send_force_disconnect != GNUNET_YES))
+          ps = ps_tmp;
+        break;
+      }
+      ps_tmp = ps_tmp->next;
+    }
+
+    if (ps == NULL)
+    {
+      ps = GNUNET_malloc (sizeof (struct Session));
+      ps->addr = GNUNET_malloc (addr_len);
+      memcpy (ps->addr, addr, addr_len);
+      ps->addrlen = addr_len;
+      ps->direction = INBOUND;
+      ps->pending_msgs_head = NULL;
+      ps->pending_msgs_tail = NULL;
+      ps->send_connected = GNUNET_NO;
+      ps->send_active = GNUNET_NO;
+      ps->recv_connected = GNUNET_NO;
+      ps->recv_active = GNUNET_NO;
+      ps->peercontext = pc;
+      ps->session_id = id_num;
+      ps->queue_length_cur = 0;
+      ps->queue_length_max = GNUNET_SERVER_MAX_MESSAGE_SIZE;
+      ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
+      GNUNET_CONTAINER_DLL_insert (pc->head, pc->tail, ps);
+      GNUNET_STATISTICS_update (plugin->env->stats,
+                                gettext_noop
+                                ("# HTTP inbound sessions for peers active"), 1,
+                                GNUNET_NO);
+    }
+
+    *httpSessionCache = ps;
+    if (ps->msgtok == NULL)
+      ps->msgtok = GNUNET_SERVER_mst_create (&mhd_write_mst_cb, ps);
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: HTTP Daemon has new an incoming `%s' request from peer `%s' (`%s')\n",
-                  ps,
-                  method,
-                  GNUNET_i2s(&pc->identity),
-                  http_plugin_address_to_string(NULL, ps->addr, ps->addrlen));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: HTTP Daemon has new an incoming `%s' request from peer `%s' (`%s')\n",
+                ps,
+                method,
+                GNUNET_i2s (&pc->identity),
+                http_plugin_address_to_string (NULL, ps->addr, ps->addrlen));
 #endif
-    }
-  
+  }
+
   /* Is it a PUT or a GET request */
   if (0 == strcmp (MHD_HTTP_METHOD_PUT, method))
+  {
+    if (ps->recv_force_disconnect == GNUNET_YES)
     {
-      if (ps->recv_force_disconnect == GNUNET_YES)
-        {
-#if DEBUG_CONNECTIONS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connection %X: inbound connection was forced to disconnect\n",ps);
-#endif
-          ps->recv_active = GNUNET_NO;
-          return MHD_NO;
-        }
-      if ((*upload_data_size == 0) && (ps->recv_active==GNUNET_NO))
-        {
-          ps->recv_endpoint = mhd_connection;
-          ps->recv_connected = GNUNET_YES;
-          ps->recv_active = GNUNET_YES;
-          ps->recv_force_disconnect = GNUNET_NO;
-#if DEBUG_CONNECTIONS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connection %X: inbound PUT connection connected\n",ps);
-#endif
-          return MHD_YES;
-        }
-      
-      /* Transmission of all data complete */
-      if ((*upload_data_size == 0) && (ps->recv_active == GNUNET_YES))
-        {
-          response = MHD_create_response_from_data (strlen (HTTP_PUT_RESPONSE),
-                                                    HTTP_PUT_RESPONSE, 
-                                                    MHD_NO, MHD_NO);
-          res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
 #if DEBUG_CONNECTIONS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connection %X: Sent HTTP/1.1: 200 OK as PUT Response\n",
-                      ps);
-#endif
-          MHD_destroy_response (response);
-          ps->recv_active=GNUNET_NO;
-          return MHD_YES;
-        }
-      
-      /* Recieving data */
-      if ((*upload_data_size > 0) && (ps->recv_active == GNUNET_YES))
-        {
-          if (pc->delay.rel_value == 0)
-            {
-#if DEBUG_HTTP
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Connection %X: PUT with %u bytes forwarded to MST\n", 
-                          ps, *upload_data_size);
-#endif
-              res = GNUNET_SERVER_mst_receive(ps->msgtok, ps, 
-                                              upload_data, *upload_data_size, 
-                                              GNUNET_NO, GNUNET_NO);
-              (*upload_data_size) = 0;
-            }
-          else
-            {
-#if DEBUG_HTTP
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Connection %X: no inbound bandwidth available! Next read was delayed for  %llu ms\n", 
-                          ps, 
-                          ps->peercontext->delay.rel_value);
-#endif
-            }
-          return MHD_YES;
-        }
-      else
-        return MHD_NO;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connection %X: inbound connection was forced to disconnect\n",
+                  ps);
+#endif
+      ps->recv_active = GNUNET_NO;
+      return MHD_NO;
     }
-  if ( 0 == strcmp (MHD_HTTP_METHOD_GET, method) )
+    if ((*upload_data_size == 0) && (ps->recv_active == GNUNET_NO))
     {
-      if (ps->send_force_disconnect == GNUNET_YES)
-        {
+      ps->recv_endpoint = mhd_connection;
+      ps->recv_connected = GNUNET_YES;
+      ps->recv_active = GNUNET_YES;
+      ps->recv_force_disconnect = GNUNET_NO;
 #if DEBUG_CONNECTIONS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connection %X: outbound connection was  forced to disconnect\n",
-                      ps);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connection %X: inbound PUT connection connected\n", ps);
 #endif
-          ps->send_active = GNUNET_NO;
-          return MHD_NO;
-        }
-      ps->send_connected = GNUNET_YES;
-      ps->send_active = GNUNET_YES;
-      ps->send_endpoint = mhd_connection;
-      ps->send_force_disconnect = GNUNET_NO;
+      return MHD_YES;
+    }
+
+    /* Transmission of all data complete */
+    if ((*upload_data_size == 0) && (ps->recv_active == GNUNET_YES))
+    {
+      response = MHD_create_response_from_data (strlen (HTTP_PUT_RESPONSE),
+                                                HTTP_PUT_RESPONSE,
+                                                MHD_NO, MHD_NO);
+      res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
 #if DEBUG_CONNECTIONS
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: inbound GET connection connected\n",
-                  ps);
+                  "Connection %X: Sent HTTP/1.1: 200 OK as PUT Response\n", ps);
 #endif
-      response = MHD_create_response_from_callback(-1,32 * 1024, &mhd_send_callback, ps, NULL);
-      res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
       MHD_destroy_response (response);
+      ps->recv_active = GNUNET_NO;
       return MHD_YES;
     }
+
+    /* Recieving data */
+    if ((*upload_data_size > 0) && (ps->recv_active == GNUNET_YES))
+    {
+      if (pc->delay.rel_value == 0)
+      {
+#if DEBUG_HTTP
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Connection %X: PUT with %u bytes forwarded to MST\n",
+                    ps, *upload_data_size);
+#endif
+        res = GNUNET_SERVER_mst_receive (ps->msgtok, ps,
+                                         upload_data, *upload_data_size,
+                                         GNUNET_NO, GNUNET_NO);
+        (*upload_data_size) = 0;
+      }
+      else
+      {
+#if DEBUG_HTTP
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Connection %X: no inbound bandwidth available! Next read was delayed for  %llu ms\n",
+                    ps, ps->peercontext->delay.rel_value);
+#endif
+      }
+      return MHD_YES;
+    }
+    else
+      return MHD_NO;
+  }
+  if (0 == strcmp (MHD_HTTP_METHOD_GET, method))
+  {
+    if (ps->send_force_disconnect == GNUNET_YES)
+    {
+#if DEBUG_CONNECTIONS
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connection %X: outbound connection was  forced to disconnect\n",
+                  ps);
+#endif
+      ps->send_active = GNUNET_NO;
+      return MHD_NO;
+    }
+    ps->send_connected = GNUNET_YES;
+    ps->send_active = GNUNET_YES;
+    ps->send_endpoint = mhd_connection;
+    ps->send_force_disconnect = GNUNET_NO;
+#if DEBUG_CONNECTIONS
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: inbound GET connection connected\n", ps);
+#endif
+    response =
+        MHD_create_response_from_callback (-1, 32 * 1024, &mhd_send_callback,
+                                           ps, NULL);
+    res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
+    MHD_destroy_response (response);
+    return MHD_YES;
+  }
   return MHD_NO;
 }
 
@@ -1451,7 +1446,7 @@ mhd_access_cb (void *cls,
  */
 static GNUNET_SCHEDULER_TaskIdentifier
 http_server_daemon_prepare (struct Plugin *plugin,
-                            struct MHD_Daemon *daemon_handle)
+                            struct MHD_Daemon *daemon_handle)
 {
   GNUNET_SCHEDULER_TaskIdentifier ret;
   fd_set rs;
@@ -1466,19 +1461,14 @@ http_server_daemon_prepare (struct Plugin *plugin,
   struct GNUNET_TIME_Relative tv;
 
   ret = GNUNET_SCHEDULER_NO_TASK;
-  FD_ZERO(&rs);
-  FD_ZERO(&ws);
-  FD_ZERO(&es);
+  FD_ZERO (&rs);
+  FD_ZERO (&ws);
+  FD_ZERO (&es);
   wrs = GNUNET_NETWORK_fdset_create ();
   wes = GNUNET_NETWORK_fdset_create ();
   wws = GNUNET_NETWORK_fdset_create ();
   max = -1;
-  GNUNET_assert (MHD_YES ==
-                 MHD_get_fdset (daemon_handle,
-                                &rs,
-                                &ws,
-                                &es,
-                                &max));
+  GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max));
   haveto = MHD_get_timeout (daemon_handle, &timeout);
   if (haveto == MHD_YES)
     tv.rel_value = (uint64_t) timeout;
@@ -1488,37 +1478,33 @@ http_server_daemon_prepare (struct Plugin *plugin,
   GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
   GNUNET_NETWORK_fdset_copy_native (wes, &es, max + 1);
   if (daemon_handle == plugin->http_server_daemon_v4)
+  {
+    if (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
     {
-      if (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel(plugin->http_server_task_v4);
-          plugin->http_server_daemon_v4 = GNUNET_SCHEDULER_NO_TASK;
-        }
-      
-      ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                         GNUNET_SCHEDULER_NO_TASK,
-                                         tv,
-                                         wrs,
-                                         wws,
-                                         &http_server_daemon_v4_run,
-                                         plugin);
+      GNUNET_SCHEDULER_cancel (plugin->http_server_task_v4);
+      plugin->http_server_daemon_v4 = GNUNET_SCHEDULER_NO_TASK;
     }
+
+    ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                       GNUNET_SCHEDULER_NO_TASK,
+                                       tv,
+                                       wrs,
+                                       wws, &http_server_daemon_v4_run, plugin);
+  }
   if (daemon_handle == plugin->http_server_daemon_v6)
+  {
+    if (plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
     {
-      if (plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel(plugin->http_server_task_v6);
-          plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
-        }
-      
-      ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                         GNUNET_SCHEDULER_NO_TASK,
-                                         tv,
-                                         wrs,
-                                         wws,
-                                         &http_server_daemon_v6_run,
-                                         plugin);
+      GNUNET_SCHEDULER_cancel (plugin->http_server_task_v6);
+      plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
     }
+
+    ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                       GNUNET_SCHEDULER_NO_TASK,
+                                       tv,
+                                       wrs,
+                                       wws, &http_server_daemon_v6_run, plugin);
+  }
   GNUNET_NETWORK_fdset_destroy (wrs);
   GNUNET_NETWORK_fdset_destroy (wws);
   GNUNET_NETWORK_fdset_destroy (wes);
@@ -1532,39 +1518,40 @@ http_server_daemon_prepare (struct Plugin *plugin,
  * @param cls plugin as closure
  * @param tc task context
  */
-static void 
+static void
 http_server_daemon_v4_run (void *cls,
-                           const struct GNUNET_SCHEDULER_TaskContext *tc)
+                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
 
 #if DEBUG_SCHEDULING
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "http_server_daemon_v4_run: GNUNET_SCHEDULER_REASON_READ_READY\n");
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "http_server_daemon_v4_run: GNUNET_SCHEDULER_REASON_WRITE_READY\n");
+                "http_server_daemon_v4_run: GNUNET_SCHEDULER_REASON_READ_READY\n");
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY))
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v4_run: GNUNET_SCHEDULER_REASON_WRITE_READY\n");
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "http_server_daemon_v4_run: GNUNET_SCHEDULER_REASON_TIMEOUT\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v4_run: GNUNET_SCHEDULER_REASON_TIMEOUT\n");
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_STARTUP))
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "http_server_daemon_v4_run: GGNUNET_SCHEDULER_REASON_STARTUP\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v4_run: GGNUNET_SCHEDULER_REASON_STARTUP\n");
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "http_server_daemon_v4_run: GGNUNET_SCHEDULER_REASON_SHUTDOWN\n");
-#endif              
-      
-  GNUNET_assert(cls !=NULL);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v4_run: GGNUNET_SCHEDULER_REASON_SHUTDOWN\n");
+#endif
+
+  GNUNET_assert (cls != NULL);
   plugin->http_server_task_v4 = GNUNET_SCHEDULER_NO_TASK;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
   GNUNET_assert (MHD_YES == MHD_run (plugin->http_server_daemon_v4));
-  plugin->http_server_task_v4 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v4);
- }
+  plugin->http_server_task_v4 =
+      http_server_daemon_prepare (plugin, plugin->http_server_daemon_v4);
+}
 
 
 /**
@@ -1573,92 +1560,95 @@ http_server_daemon_v4_run (void *cls,
  * @param cls plugin as closure
  * @param tc task context
  */
-static void 
+static void
 http_server_daemon_v6_run (void *cls,
-                           const struct GNUNET_SCHEDULER_TaskContext *tc)
+                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
-  
-#if DEBUG_SCHEDULING  
+
+#if DEBUG_SCHEDULING
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "http_server_daemon_v6_run: GNUNET_SCHEDULER_REASON_READ_READY\n");
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "http_server_daemon_v6_run: GNUNET_SCHEDULER_REASON_WRITE_READY\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v6_run: GNUNET_SCHEDULER_REASON_READ_READY\n");
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY))
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v6_run: GNUNET_SCHEDULER_REASON_WRITE_READY\n");
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "http_server_daemon_v6_run: GNUNET_SCHEDULER_REASON_TIMEOUT\n");
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_STARTUP))  
-     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "http_server_daemon_v6_run: GGNUNET_SCHEDULER_REASON_STARTUP\n");
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))  
-     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "http_server_daemon_v6_run: GGNUNET_SCHEDULER_REASON_SHUTDOWN\n");
-#endif                                            
-
-  GNUNET_assert(cls !=NULL);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v6_run: GNUNET_SCHEDULER_REASON_TIMEOUT\n");
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_STARTUP))
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v6_run: GGNUNET_SCHEDULER_REASON_STARTUP\n");
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "http_server_daemon_v6_run: GGNUNET_SCHEDULER_REASON_SHUTDOWN\n");
+#endif
+
+  GNUNET_assert (cls != NULL);
   plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
   GNUNET_assert (MHD_YES == MHD_run (plugin->http_server_daemon_v6));
-  plugin->http_server_task_v6 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v6);
+  plugin->http_server_task_v6 =
+      http_server_daemon_prepare (plugin, plugin->http_server_daemon_v6);
 }
 
 
-static size_t 
-curl_get_header_cb( void *ptr, 
-                    size_t size, size_t nmemb, 
-                    void *stream)
+static size_t
+curl_get_header_cb (void *ptr, size_t size, size_t nmemb, void *stream)
 {
-  struct Session * ps = stream;
+  struct Session *ps = stream;
 
   long http_result = 0;
   int res;
+
   /* Getting last http result code */
-  GNUNET_assert(NULL!=ps);
-  if (ps->recv_connected==GNUNET_NO)
+  GNUNET_assert (NULL != ps);
+  if (ps->recv_connected == GNUNET_NO)
+  {
+    res =
+        curl_easy_getinfo (ps->recv_endpoint, CURLINFO_RESPONSE_CODE,
+                           &http_result);
+    if (CURLE_OK == res)
     {
-      res = curl_easy_getinfo(ps->recv_endpoint, CURLINFO_RESPONSE_CODE, &http_result);
-      if (CURLE_OK == res)
-        {
-          if (http_result == 200)
-            {
-              ps->recv_connected = GNUNET_YES;
-              ps->recv_active = GNUNET_YES;
+      if (http_result == 200)
+      {
+        ps->recv_connected = GNUNET_YES;
+        ps->recv_active = GNUNET_YES;
 #if DEBUG_CONNECTIONS
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: connected to recieve data\n",ps);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Connection %X: connected to recieve data\n", ps);
 #endif
-              // Calling send_check_connections again since receive is established
-              send_check_connections (ps->peercontext->plugin, ps);
-            }
-        }
+        // Calling send_check_connections again since receive is established
+        send_check_connections (ps->peercontext->plugin, ps);
+      }
     }
-  
+  }
+
 #if DEBUG_CURL
-  char * tmp;
+  char *tmp;
   size_t len = size * nmemb;
+
   tmp = NULL;
   if ((size * nmemb) < SIZE_MAX)
-    tmp = GNUNET_malloc (len+1);
+    tmp = GNUNET_malloc (len + 1);
 
   if ((tmp != NULL) && (len > 0))
+  {
+    memcpy (tmp, ptr, len);
+    if (len >= 2)
     {
-      memcpy(tmp,ptr,len);
-      if (len>=2)
-        {
-          if (tmp[len-2] == 13)
-            tmp[len-2]= '\0';
-        }
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: Header: %s\n",
-                  ps, tmp);
+      if (tmp[len - 2] == 13)
+        tmp[len - 2] = '\0';
     }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: Header: %s\n", ps, tmp);
+  }
   GNUNET_free_non_null (tmp);
 #endif
-  
+
   return size * nmemb;
 }
 
@@ -1672,59 +1662,56 @@ curl_get_header_cb( void *ptr,
  * @param stream closure set by user
  * @return bytes read by function
  */
-static size_t 
-curl_put_header_cb(void *ptr, 
-                   size_t size, 
-                   size_t nmemb, 
-                   void *stream)
+static size_t
+curl_put_header_cb (void *ptr, size_t size, size_t nmemb, void *stream)
 {
-  struct Session * ps = stream;
+  struct Session *ps = stream;
 
-  char * tmp;
+  char *tmp;
   size_t len = size * nmemb;
   long http_result = 0;
   int res;
 
   /* Getting last http result code */
-  GNUNET_assert(NULL!=ps);
-  res = curl_easy_getinfo (ps->send_endpoint, CURLINFO_RESPONSE_CODE, &http_result);
+  GNUNET_assert (NULL != ps);
+  res =
+      curl_easy_getinfo (ps->send_endpoint, CURLINFO_RESPONSE_CODE,
+                         &http_result);
   if (CURLE_OK == res)
+  {
+    if ((http_result == 100) && (ps->send_connected == GNUNET_NO))
     {
-      if ((http_result == 100) && (ps->send_connected==GNUNET_NO))
-        {
-          ps->send_connected = GNUNET_YES;
-          ps->send_active = GNUNET_YES;
+      ps->send_connected = GNUNET_YES;
+      ps->send_active = GNUNET_YES;
 #if DEBUG_CONNECTIONS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connection %X: connected to send data\n",
-                      ps);
-#endif
-        }
-      if ((http_result == 200) && (ps->send_connected==GNUNET_YES))
-        {
-          ps->send_connected = GNUNET_NO;
-          ps->send_active = GNUNET_NO;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connection %X: connected to send data\n", ps);
+#endif
+    }
+    if ((http_result == 200) && (ps->send_connected == GNUNET_YES))
+    {
+      ps->send_connected = GNUNET_NO;
+      ps->send_active = GNUNET_NO;
 #if DEBUG_CONNECTIONS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connection %X: sending disconnected\n",
-                      ps);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connection %X: sending disconnected\n", ps);
 #endif
-        }
     }
-  
+  }
+
   tmp = NULL;
   if ((size * nmemb) < SIZE_MAX)
-    tmp = GNUNET_malloc (len+1);
-  
+    tmp = GNUNET_malloc (len + 1);
+
   if ((tmp != NULL) && (len > 0))
+  {
+    memcpy (tmp, ptr, len);
+    if (len >= 2)
     {
-      memcpy(tmp,ptr,len);
-      if (len>=2)
-        {
-          if (tmp[len-2] == 13)
-            tmp[len-2]= '\0';
-        }
+      if (tmp[len - 2] == 13)
+        tmp[len - 2] = '\0';
     }
+  }
   GNUNET_free_non_null (tmp);
   return size * nmemb;
 }
@@ -1738,123 +1725,119 @@ curl_put_header_cb(void *ptr,
  * @param ptr source pointer, passed to the libcurl handle
  * @return bytes written to stream
  */
-static size_t 
-curl_send_cb(void *stream, 
-             size_t size, size_t nmemb, 
-             void *ptr)
+static size_t
+curl_send_cb (void *stream, size_t size, size_t nmemb, void *ptr)
 {
-  struct Session * ps = ptr;
-  struct HTTP_Message * msg = ps->pending_msgs_tail;
+  struct Session *ps = ptr;
+  struct HTTP_Message *msg = ps->pending_msgs_tail;
   size_t bytes_sent;
   size_t len;
 
   if (ps->send_active == GNUNET_NO)
     return CURL_READFUNC_PAUSE;
-  if ( (ps->pending_msgs_tail == NULL) && 
-       (ps->send_active == GNUNET_YES) )
-    {
+  if ((ps->pending_msgs_tail == NULL) && (ps->send_active == GNUNET_YES))
+  {
 #if DEBUG_CONNECTIONS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: No Message to send, pausing connection\n",
-                  ps);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: No Message to send, pausing connection\n", ps);
 #endif
-      ps->send_active = GNUNET_NO;
+    ps->send_active = GNUNET_NO;
     return CURL_READFUNC_PAUSE;
-    }
-  
-  GNUNET_assert (msg!=NULL);
-  
+  }
+
+  GNUNET_assert (msg != NULL);
+
   /* data to send */
   if (msg->pos < msg->size)
+  {
+    /* data fit in buffer */
+    if ((msg->size - msg->pos) <= (size * nmemb))
     {
-      /* data fit in buffer */
-      if ((msg->size - msg->pos) <= (size * nmemb))
-        {
-          len = (msg->size - msg->pos);
-          memcpy(stream, &msg->buf[msg->pos], len);
-          msg->pos += len;
-          bytes_sent = len;
-        }
-      else
-        {
-          len = size*nmemb;
-          memcpy(stream, &msg->buf[msg->pos], len);
-          msg->pos += len;
-          bytes_sent = len;
-        }
+      len = (msg->size - msg->pos);
+      memcpy (stream, &msg->buf[msg->pos], len);
+      msg->pos += len;
+      bytes_sent = len;
     }
-  /* no data to send */
-  else
+    else
     {
-      bytes_sent = 0;
+      len = size * nmemb;
+      memcpy (stream, &msg->buf[msg->pos], len);
+      msg->pos += len;
+      bytes_sent = len;
     }
-  
-  if ( msg->pos == msg->size)
-    {
+  }
+  /* no data to send */
+  else
+  {
+    bytes_sent = 0;
+  }
+
+  if (msg->pos == msg->size)
+  {
 #if DEBUG_CONNECTIONS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: Message with %u bytes sent, removing message from queue\n",
-                  ps, 
-                  msg->pos);
-#endif
-      /* Calling transmit continuation  */
-      if (NULL != ps->pending_msgs_tail->transmit_cont)
-        msg->transmit_cont (ps->pending_msgs_tail->transmit_cont_cls,
-                            &(ps->peercontext)->identity,
-                            GNUNET_OK);
-      ps->queue_length_cur -= msg->size;
-      remove_http_message(ps, msg);
-    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: Message with %u bytes sent, removing message from queue\n",
+                ps, msg->pos);
+#endif
+    /* Calling transmit continuation  */
+    if (NULL != ps->pending_msgs_tail->transmit_cont)
+      msg->transmit_cont (ps->pending_msgs_tail->transmit_cont_cls,
+                          &(ps->peercontext)->identity, GNUNET_OK);
+    ps->queue_length_cur -= msg->size;
+    remove_http_message (ps, msg);
+  }
   return bytes_sent;
 }
 
 
-static void 
-curl_receive_mst_cb  (void *cls,
-                      void *client,
-                      const struct GNUNET_MessageHeader *message)
+static void
+curl_receive_mst_cb (void *cls,
+                     void *client, const struct GNUNET_MessageHeader *message)
 {
-  struct Session *ps  = cls;
+  struct Session *ps = cls;
   struct GNUNET_TIME_Relative delay;
-  GNUNET_assert(ps != NULL);
+
+  GNUNET_assert (ps != NULL);
 
   struct HTTP_PeerContext *pc = ps->peercontext;
-  GNUNET_assert(pc != NULL);
+
+  GNUNET_assert (pc != NULL);
 #if DEBUG_HTTP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Connection %X: Forwarding message to transport service, type %u and size %u from `%s' (`%s')\n",
               ps,
-              ntohs(message->type),
-              ntohs(message->size),
-              GNUNET_i2s(&(pc->identity)),
-              http_plugin_address_to_string(NULL,ps->addr,ps->addrlen));
+              ntohs (message->type),
+              ntohs (message->size),
+              GNUNET_i2s (&(pc->identity)),
+              http_plugin_address_to_string (NULL, ps->addr, ps->addrlen));
 #endif
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
+
   distance[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
   distance[0].value = htonl (1);
   distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   distance[1].value = htonl (0);
 
   delay = pc->plugin->env->receive (pc->plugin->env->cls,
-                                    &pc->identity,
-                                    message,
-                                    (const struct GNUNET_TRANSPORT_ATS_Information *) &distance, 2,
-                                    ps,
-                                    ps->addr,
-                                    ps->addrlen);
+                                    &pc->identity,
+                                    message,
+                                    (const struct
+                                     GNUNET_TRANSPORT_ATS_Information *)
+                                    &distance, 2, ps, ps->addr, ps->addrlen);
   pc->delay = delay;
   if (pc->reset_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (pc->reset_task);
+    GNUNET_SCHEDULER_cancel (pc->reset_task);
 
   if (delay.rel_value > 0)
-    {
+  {
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: Inbound quota management: delay next read for %llu ms\n", 
-                  ps, delay.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: Inbound quota management: delay next read for %llu ms\n",
+                ps, delay.rel_value);
 #endif
-      pc->reset_task = GNUNET_SCHEDULER_add_delayed (delay, &reset_inbound_quota_delay, pc);
-    }
+    pc->reset_task =
+        GNUNET_SCHEDULER_add_delayed (delay, &reset_inbound_quota_delay, pc);
+  }
 }
 
 
@@ -1867,163 +1850,171 @@ curl_receive_mst_cb  (void *cls,
 * @param ptr destination pointer, passed to the libcurl handle
 * @return bytes read from stream
 */
-static size_t 
-curl_receive_cb( void *stream, size_t size, size_t nmemb, void *ptr)
+static size_t
+curl_receive_cb (void *stream, size_t size, size_t nmemb, void *ptr)
 {
-  struct Session * ps = ptr;
+  struct Session *ps = ptr;
 
   if (ps->peercontext->delay.rel_value > 0)
-    {
+  {
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection %X: no inbound bandwidth available! Next read was delayed for  %llu ms\n",
-                  ps, ps->peercontext->delay.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connection %X: no inbound bandwidth available! Next read was delayed for  %llu ms\n",
+                ps, ps->peercontext->delay.rel_value);
 #endif
-      return 0;
-    }  
+    return 0;
+  }
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connection %X: %u bytes received\n",
-              ps, size*nmemb);
+              "Connection %X: %u bytes received\n", ps, size * nmemb);
 #endif
-  GNUNET_SERVER_mst_receive(ps->msgtok, ps, 
-                            stream, size*nmemb, 
-                            GNUNET_NO, GNUNET_NO);
+  GNUNET_SERVER_mst_receive (ps->msgtok, ps,
+                             stream, size * nmemb, GNUNET_NO, GNUNET_NO);
   return (size * nmemb);
 }
 
 
-static void 
+static void
 curl_handle_finished (struct Plugin *plugin)
 {
   struct Session *ps = NULL;
   struct HTTP_PeerContext *pc = NULL;
   struct CURLMsg *msg;
-  struct HTTP_Message * cur_msg = NULL;
+  struct HTTP_Message *cur_msg = NULL;
   int msgs_in_queue;
-  char * tmp;
+  char *tmp;
   long http_result;
-  
+
   do
-    {
-      msg = curl_multi_info_read (plugin->multi_handle, &msgs_in_queue);
-      if ((msgs_in_queue == 0) || (msg == NULL))
-        break;
-      /* get session for affected curl handle */
-      GNUNET_assert ( msg->easy_handle != NULL );
-      curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &tmp);
-      ps = (struct Session *) tmp;
-      GNUNET_assert ( ps != NULL );
-      pc = ps->peercontext;
-      GNUNET_assert ( pc != NULL );
-      switch (msg->msg)
-        {
-        case CURLMSG_DONE:
-          if ( (msg->data.result != CURLE_OK) &&
-               (msg->data.result != CURLE_GOT_NOTHING) )
-            {
-              /* sending msg failed*/
-              if (msg->easy_handle == ps->send_endpoint)
-                {
+  {
+    msg = curl_multi_info_read (plugin->multi_handle, &msgs_in_queue);
+    if ((msgs_in_queue == 0) || (msg == NULL))
+      break;
+    /* get session for affected curl handle */
+    GNUNET_assert (msg->easy_handle != NULL);
+    curl_easy_getinfo (msg->easy_handle, CURLINFO_PRIVATE, &tmp);
+    ps = (struct Session *) tmp;
+    GNUNET_assert (ps != NULL);
+    pc = ps->peercontext;
+    GNUNET_assert (pc != NULL);
+    switch (msg->msg)
+    {
+    case CURLMSG_DONE:
+      if ((msg->data.result != CURLE_OK) &&
+          (msg->data.result != CURLE_GOT_NOTHING))
+      {
+        /* sending msg failed */
+        if (msg->easy_handle == ps->send_endpoint)
+        {
 #if DEBUG_CONNECTIONS
-                  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                             _("Connection %X: HTTP PUT to peer `%s' (`%s') failed: `%s' `%s'\n"),
-                             ps,
-                             GNUNET_i2s(&pc->identity),
-                             http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
-                             "curl_multi_perform",
-                             curl_easy_strerror (msg->data.result));
-#endif
-                  ps->send_connected = GNUNET_NO;
-                  ps->send_active = GNUNET_NO;
-                  curl_multi_remove_handle(plugin->multi_handle,ps->send_endpoint);
-                  while (ps->pending_msgs_tail != NULL)
-                    {
-                      cur_msg = ps->pending_msgs_tail;
-                      if ( NULL != cur_msg->transmit_cont)
-                        cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_SYSERR);
-                      ps->queue_length_cur -= cur_msg->size;
-                      remove_http_message(ps,cur_msg);
-                    }
-                }
-              /* GET connection failed */
-              if (msg->easy_handle == ps->recv_endpoint)
-                {
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _
+                      ("Connection %X: HTTP PUT to peer `%s' (`%s') failed: `%s' `%s'\n"),
+                      ps, GNUNET_i2s (&pc->identity),
+                      http_plugin_address_to_string (NULL, ps->addr,
+                                                     ps->addrlen),
+                      "curl_multi_perform",
+                      curl_easy_strerror (msg->data.result));
+#endif
+          ps->send_connected = GNUNET_NO;
+          ps->send_active = GNUNET_NO;
+          curl_multi_remove_handle (plugin->multi_handle, ps->send_endpoint);
+          while (ps->pending_msgs_tail != NULL)
+          {
+            cur_msg = ps->pending_msgs_tail;
+            if (NULL != cur_msg->transmit_cont)
+              cur_msg->transmit_cont (cur_msg->transmit_cont_cls, &pc->identity,
+                                      GNUNET_SYSERR);
+            ps->queue_length_cur -= cur_msg->size;
+            remove_http_message (ps, cur_msg);
+          }
+        }
+        /* GET connection failed */
+        if (msg->easy_handle == ps->recv_endpoint)
+        {
 #if DEBUG_CONNECTIONS
-                  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                             _("Connection %X: HTTP GET to peer `%s' (`%s') failed: `%s' `%s'\n"),
-                             ps,
-                             GNUNET_i2s(&pc->identity),
-                             http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
-                             "curl_multi_perform",
-                             curl_easy_strerror (msg->data.result));
-#endif
-                  ps->recv_connected = GNUNET_NO;
-                  ps->recv_active = GNUNET_NO;
-                  curl_multi_remove_handle(plugin->multi_handle,ps->recv_endpoint);
-                }
-            }
-          else
-            {
-              if (msg->easy_handle == ps->send_endpoint)
-                {
-                  GNUNET_assert (CURLE_OK == curl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &http_result));
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _
+                      ("Connection %X: HTTP GET to peer `%s' (`%s') failed: `%s' `%s'\n"),
+                      ps, GNUNET_i2s (&pc->identity),
+                      http_plugin_address_to_string (NULL, ps->addr,
+                                                     ps->addrlen),
+                      "curl_multi_perform",
+                      curl_easy_strerror (msg->data.result));
+#endif
+          ps->recv_connected = GNUNET_NO;
+          ps->recv_active = GNUNET_NO;
+          curl_multi_remove_handle (plugin->multi_handle, ps->recv_endpoint);
+        }
+      }
+      else
+      {
+        if (msg->easy_handle == ps->send_endpoint)
+        {
+          GNUNET_assert (CURLE_OK ==
+                         curl_easy_getinfo (msg->easy_handle,
+                                            CURLINFO_RESPONSE_CODE,
+                                            &http_result));
 #if DEBUG_CONNECTIONS
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                              "Connection %X: HTTP PUT connection to peer `%s' (`%s') was closed with HTTP code %u\n",
-                              ps,
-                              GNUNET_i2s(&pc->identity),
-                              http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
-                              http_result);
-#endif
-                  /* Calling transmit continuation  */
-                  while (ps->pending_msgs_tail != NULL)
-                    {
-                      cur_msg = ps->pending_msgs_tail;
-                      if ( NULL != cur_msg->transmit_cont)
-                        {
-                          /* HTTP 1xx : Last message before here was informational */
-                          if ((http_result >=100) && (http_result < 200))
-                            cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_OK);
-                          /* HTTP 2xx: successful operations */
-                          if ((http_result >=200) && (http_result < 300))
-                            cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_OK);
-                          /* HTTP 3xx..5xx: error */
-                          if ((http_result >=300) && (http_result < 600))
-                            cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_SYSERR);
-                        }
-                      ps->queue_length_cur -= cur_msg->size;
-                      remove_http_message(ps,cur_msg);
-                    }
-                  
-                  ps->send_connected = GNUNET_NO;
-                  ps->send_active = GNUNET_NO;
-                  curl_multi_remove_handle(plugin->multi_handle,ps->send_endpoint);
-                }
-              if (msg->easy_handle == ps->recv_endpoint)
-                {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Connection %X: HTTP PUT connection to peer `%s' (`%s') was closed with HTTP code %u\n",
+                      ps,
+                      GNUNET_i2s (&pc->identity),
+                      http_plugin_address_to_string (NULL, ps->addr,
+                                                     ps->addrlen), http_result);
+#endif
+          /* Calling transmit continuation  */
+          while (ps->pending_msgs_tail != NULL)
+          {
+            cur_msg = ps->pending_msgs_tail;
+            if (NULL != cur_msg->transmit_cont)
+            {
+              /* HTTP 1xx : Last message before here was informational */
+              if ((http_result >= 100) && (http_result < 200))
+                cur_msg->transmit_cont (cur_msg->transmit_cont_cls,
+                                        &pc->identity, GNUNET_OK);
+              /* HTTP 2xx: successful operations */
+              if ((http_result >= 200) && (http_result < 300))
+                cur_msg->transmit_cont (cur_msg->transmit_cont_cls,
+                                        &pc->identity, GNUNET_OK);
+              /* HTTP 3xx..5xx: error */
+              if ((http_result >= 300) && (http_result < 600))
+                cur_msg->transmit_cont (cur_msg->transmit_cont_cls,
+                                        &pc->identity, GNUNET_SYSERR);
+            }
+            ps->queue_length_cur -= cur_msg->size;
+            remove_http_message (ps, cur_msg);
+          }
+
+          ps->send_connected = GNUNET_NO;
+          ps->send_active = GNUNET_NO;
+          curl_multi_remove_handle (plugin->multi_handle, ps->send_endpoint);
+        }
+        if (msg->easy_handle == ps->recv_endpoint)
+        {
 #if DEBUG_CONNECTIONS
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                              "Connection %X: HTTP GET connection to peer `%s' (`%s') was closed with HTTP code %u\n",
-                              ps,
-                              GNUNET_i2s(&pc->identity),
-                              http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
-                              http_result);
-#endif
-                  ps->recv_connected = GNUNET_NO;
-                  ps->recv_active = GNUNET_NO;
-                  curl_multi_remove_handle(plugin->multi_handle,ps->recv_endpoint);
-                }
-              plugin->current_connections--;
-            }
-          if ((ps->recv_connected == GNUNET_NO) && (ps->send_connected == GNUNET_NO))
-            remove_session (pc, ps, GNUNET_YES, GNUNET_SYSERR);
-          break;
-        default:
-          break;
-        }
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Connection %X: HTTP GET connection to peer `%s' (`%s') was closed with HTTP code %u\n",
+                      ps,
+                      GNUNET_i2s (&pc->identity),
+                      http_plugin_address_to_string (NULL, ps->addr,
+                                                     ps->addrlen), http_result);
+#endif
+          ps->recv_connected = GNUNET_NO;
+          ps->recv_active = GNUNET_NO;
+          curl_multi_remove_handle (plugin->multi_handle, ps->recv_endpoint);
+        }
+        plugin->current_connections--;
+      }
+      if ((ps->recv_connected == GNUNET_NO) &&
+          (ps->send_connected == GNUNET_NO))
+        remove_session (pc, ps, GNUNET_YES, GNUNET_SYSERR);
+      break;
+    default:
+      break;
     }
-  while ( (msgs_in_queue > 0) );
+  }
+  while ((msgs_in_queue > 0));
 }
 
 
@@ -2032,29 +2023,29 @@ curl_handle_finished (struct Plugin *plugin)
  * @param cls plugin as closure
  * @param tc gnunet scheduler task context
  */
-static void curl_perform (void *cls,
-                          const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+curl_perform (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
   static unsigned int handles_last_run;
   int running;
   CURLMcode mret;
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
 
   plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   do
-    {
-      running = 0;
-      mret = curl_multi_perform (plugin->multi_handle, &running);
-      if ((running < handles_last_run) && (running>0))
-          curl_handle_finished(plugin);
-      handles_last_run = running;
-    }
+  {
+    running = 0;
+    mret = curl_multi_perform (plugin->multi_handle, &running);
+    if ((running < handles_last_run) && (running > 0))
+      curl_handle_finished (plugin);
+    handles_last_run = running;
+  }
   while (mret == CURLM_CALL_MULTI_PERFORM);
-  curl_schedule(plugin);
+  curl_schedule (plugin);
 }
 
 
@@ -2064,8 +2055,8 @@ static void curl_perform (void *cls,
  * @param  plugin plugin as closure
  * @return GNUNET_SYSERR for hard failure, GNUNET_OK for ok
  */
-static int 
-curl_schedule(struct Plugin *plugin)
+static int
+curl_schedule (struct Plugin *plugin)
 {
   fd_set rs;
   fd_set ws;
@@ -2077,48 +2068,50 @@ curl_schedule(struct Plugin *plugin)
   CURLMcode mret;
 
   /* Cancel previous scheduled task */
-  if (plugin->http_curl_task !=  GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
-      plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  
+  if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (plugin->http_curl_task);
+    plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+
   max = -1;
   FD_ZERO (&rs);
   FD_ZERO (&ws);
   FD_ZERO (&es);
   mret = curl_multi_fdset (plugin->multi_handle, &rs, &ws, &es, &max);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_fdset", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_fdset", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return GNUNET_SYSERR;
+  }
   mret = curl_multi_timeout (plugin->multi_handle, &to);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_timeout", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_timeout", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return GNUNET_SYSERR;
+  }
 
   grs = GNUNET_NETWORK_fdset_create ();
   gws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
   GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
-  plugin->http_curl_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                        GNUNET_SCHEDULER_NO_TASK,
-                                                        (to == -1) 
-                                                        ? GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
-                                                        : GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to),
-                                                        grs,
-                                                        gws,
-                                                        &curl_perform,
-                                                        plugin);
+  plugin->http_curl_task =
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   (to ==
+                                    -1) ?
+                                   GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_SECONDS,
+                                    5) :
+                                   GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_MILLISECONDS, to), grs,
+                                   gws, &curl_perform, plugin);
   GNUNET_NETWORK_fdset_destroy (gws);
   GNUNET_NETWORK_fdset_destroy (grs);
   return GNUNET_OK;
@@ -2135,28 +2128,24 @@ curl_schedule(struct Plugin *plugin)
  * @param cls  closure
  * @return 0
  */
-static int 
+static int
 curl_logger (CURL * curl,
-             curl_infotype type, 
-             char * data, size_t size, 
-             void * cls)
+             curl_infotype type, char *data, size_t size, void *cls)
 {
   if (type == CURLINFO_TEXT)
+  {
+    char text[size + 2];
+
+    memcpy (text, data, size);
+    if (text[size - 1] == '\n')
+      text[size] = '\0';
+    else
     {
-      char text[size+2];
-      memcpy(text,data,size);
-      if (text[size-1] == '\n')
-        text[size] = '\0';
-      else
-        {
-          text[size] = '\n';
-          text[size+1] = '\0';
-        }
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "CURL: Connection %X - %s", 
-                  cls, 
-                  text);
+      text[size] = '\n';
+      text[size + 1] = '\0';
     }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CURL: Connection %X - %s", cls, text);
+  }
   return 0;
 }
 #endif
@@ -2169,184 +2158,203 @@ curl_logger (CURL * curl,
  * @param ps session
  * @return GNUNET_SYSERR on failure, GNUNET_NO if connecting, GNUNET_YES if ok
  */
-static int 
-send_check_connections (struct Plugin *plugin, 
-                        struct Session *ps)
+static int
+send_check_connections (struct Plugin *plugin, struct Session *ps)
 {
   CURLMcode mret;
-  struct GNUNET_TIME_Relative timeout = GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT;
+  struct GNUNET_TIME_Relative timeout =
+      GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT;
 
-  if ((ps->direction == OUTBOUND) && (plugin->current_connections < plugin->max_connect_per_transport))
+  if ((ps->direction == OUTBOUND) &&
+      (plugin->current_connections < plugin->max_connect_per_transport))
+  {
+    /* RECV DIRECTION */
+    /* Check if session is connected to receive data, otherwise connect to peer */
+
+    if (ps->recv_connected == GNUNET_NO)
     {
-      /* RECV DIRECTION */
-      /* Check if session is connected to receive data, otherwise connect to peer */
-
-      if (ps->recv_connected == GNUNET_NO)
-        {
-          int fresh = GNUNET_NO;
-          if (ps->recv_endpoint == NULL)
-            {
-              fresh = GNUNET_YES;
-              ps->recv_endpoint = curl_easy_init();
-            }
+      int fresh = GNUNET_NO;
+
+      if (ps->recv_endpoint == NULL)
+      {
+        fresh = GNUNET_YES;
+        ps->recv_endpoint = curl_easy_init ();
+      }
 #if DEBUG_CURL
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_VERBOSE, 1L);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_DEBUGFUNCTION , &curl_logger);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_DEBUGDATA , ps->recv_endpoint);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_VERBOSE, 1L);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_DEBUGFUNCTION, &curl_logger);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_DEBUGDATA,
+                        ps->recv_endpoint);
 #endif
 #if BUILD_HTTPS
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
-#endif
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_URL, ps->url);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_HEADERFUNCTION, &curl_get_header_cb);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_WRITEHEADER, ps);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_READFUNCTION, curl_send_cb);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_READDATA, ps);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_WRITEFUNCTION, curl_receive_cb);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_WRITEDATA, ps);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_TIMEOUT, (long) timeout.rel_value);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_PRIVATE, ps);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_CONNECTTIMEOUT, HTTP_CONNECT_TIMEOUT);
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_BUFFERSIZE, 2*GNUNET_SERVER_MAX_MESSAGE_SIZE);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_SSLVERSION,
+                        CURL_SSLVERSION_TLSv1);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
+#endif
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_URL, ps->url);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_HEADERFUNCTION,
+                        &curl_get_header_cb);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_WRITEHEADER, ps);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_READFUNCTION, curl_send_cb);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_READDATA, ps);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_WRITEFUNCTION,
+                        curl_receive_cb);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_WRITEDATA, ps);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_TIMEOUT,
+                        (long) timeout.rel_value);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_PRIVATE, ps);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_CONNECTTIMEOUT,
+                        HTTP_CONNECT_TIMEOUT);
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_BUFFERSIZE,
+                        2 * GNUNET_SERVER_MAX_MESSAGE_SIZE);
 #if CURL_TCP_NODELAY
-          curl_easy_setopt(ps->recv_endpoint, CURLOPT_TCP_NODELAY, 1);
-#endif
-          if (fresh==GNUNET_YES)
-            {
-              mret = curl_multi_add_handle(plugin->multi_handle, ps->recv_endpoint);
-              if (mret != CURLM_OK)
-                {
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                              _("Connection: %X: %s failed at %s:%d: `%s'\n"),
-                              ps,
-                              "curl_multi_add_handle", __FILE__, __LINE__,
-                              curl_multi_strerror (mret));
-                  return GNUNET_SYSERR;
-                }
-            }
-          if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
-            {
-              GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
-              plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
-            }
-          plugin->current_connections ++;
-          plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
-        }
-      
-      /* waiting for receive direction */
-      if (ps->recv_connected==GNUNET_NO)
-        return GNUNET_NO;
-      
-      /* SEND DIRECTION */
-      /* Check if session is connected to send data, otherwise connect to peer */
-      if ((ps->send_connected == GNUNET_YES) && (ps->send_endpoint!= NULL))
-        {
-          if (ps->send_active == GNUNET_YES)
-            {
+      curl_easy_setopt (ps->recv_endpoint, CURLOPT_TCP_NODELAY, 1);
+#endif
+      if (fresh == GNUNET_YES)
+      {
+        mret = curl_multi_add_handle (plugin->multi_handle, ps->recv_endpoint);
+        if (mret != CURLM_OK)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Connection: %X: %s failed at %s:%d: `%s'\n"),
+                      ps,
+                      "curl_multi_add_handle", __FILE__, __LINE__,
+                      curl_multi_strerror (mret));
+          return GNUNET_SYSERR;
+        }
+      }
+      if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
+      {
+        GNUNET_SCHEDULER_cancel (plugin->http_curl_task);
+        plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
+      }
+      plugin->current_connections++;
+      plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
+    }
+
+    /* waiting for receive direction */
+    if (ps->recv_connected == GNUNET_NO)
+      return GNUNET_NO;
+
+    /* SEND DIRECTION */
+    /* Check if session is connected to send data, otherwise connect to peer */
+    if ((ps->send_connected == GNUNET_YES) && (ps->send_endpoint != NULL))
+    {
+      if (ps->send_active == GNUNET_YES)
+      {
 #if DEBUG_CONNECTIONS
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Connection %X: outbound active, enqueueing message\n",
-                          ps);
-#endif
-              return GNUNET_YES;
-            }
-          if (ps->send_active == GNUNET_NO)
-            {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Connection %X: outbound active, enqueueing message\n", ps);
+#endif
+        return GNUNET_YES;
+      }
+      if (ps->send_active == GNUNET_NO)
+      {
 #if DEBUG_CONNECTIONS
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Connection %X: outbound paused, unpausing existing connection and enqueueing message\n",
-                          ps);
-#endif
-              if (CURLE_OK == curl_easy_pause(ps->send_endpoint,CURLPAUSE_CONT))
-                {
-                  ps->send_active=GNUNET_YES;
-                  if (plugin->http_curl_task !=  GNUNET_SCHEDULER_NO_TASK)
-                    {
-                      GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
-                      plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
-                    }
-                  plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
-                  return GNUNET_YES;
-                }
-              else
-                return GNUNET_SYSERR;
-            }
-        }
-      /* not connected, initiate connection */
-      if ((ps->send_connected==GNUNET_NO) && (plugin->current_connections < plugin->max_connect_per_transport))
-        {
-          int fresh = GNUNET_NO;
-          if (NULL == ps->send_endpoint)
-            {
-              ps->send_endpoint = curl_easy_init();
-              fresh = GNUNET_YES;
-            }
-          GNUNET_assert (ps->send_endpoint != NULL);
-          GNUNET_assert (NULL != ps->pending_msgs_tail);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Connection %X: outbound paused, unpausing existing connection and enqueueing message\n",
+                    ps);
+#endif
+        if (CURLE_OK == curl_easy_pause (ps->send_endpoint, CURLPAUSE_CONT))
+        {
+          ps->send_active = GNUNET_YES;
+          if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
+          {
+            GNUNET_SCHEDULER_cancel (plugin->http_curl_task);
+            plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
+          }
+          plugin->http_curl_task =
+              GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
+          return GNUNET_YES;
+        }
+        else
+          return GNUNET_SYSERR;
+      }
+    }
+    /* not connected, initiate connection */
+    if ((ps->send_connected == GNUNET_NO) &&
+        (plugin->current_connections < plugin->max_connect_per_transport))
+    {
+      int fresh = GNUNET_NO;
+
+      if (NULL == ps->send_endpoint)
+      {
+        ps->send_endpoint = curl_easy_init ();
+        fresh = GNUNET_YES;
+      }
+      GNUNET_assert (ps->send_endpoint != NULL);
+      GNUNET_assert (NULL != ps->pending_msgs_tail);
 #if DEBUG_CONNECTIONS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connection %X: outbound not connected, initiating connection\n",
-                      ps);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connection %X: outbound not connected, initiating connection\n",
+                  ps);
 #endif
-          ps->send_active = GNUNET_NO;
-          
+      ps->send_active = GNUNET_NO;
+
 #if DEBUG_CURL
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_VERBOSE, 1L);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_DEBUGFUNCTION , &curl_logger);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_DEBUGDATA , ps->send_endpoint);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_VERBOSE, 1L);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_DEBUGFUNCTION, &curl_logger);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_DEBUGDATA,
+                        ps->send_endpoint);
 #endif
 #if BUILD_HTTPS
-          curl_easy_setopt (ps->send_endpoint, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
-#endif
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_URL, ps->url);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_PUT, 1L);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_HEADERFUNCTION, &curl_put_header_cb);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_WRITEHEADER, ps);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_READFUNCTION, curl_send_cb);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_READDATA, ps);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_WRITEFUNCTION, curl_receive_cb);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_READDATA, ps);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_TIMEOUT, (long) timeout.rel_value);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_PRIVATE, ps);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_CONNECTTIMEOUT, HTTP_CONNECT_TIMEOUT);
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_BUFFERSIZE, 2 * GNUNET_SERVER_MAX_MESSAGE_SIZE);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_SSLVERSION,
+                        CURL_SSLVERSION_TLSv1);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
+#endif
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_URL, ps->url);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_PUT, 1L);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_HEADERFUNCTION,
+                        &curl_put_header_cb);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_WRITEHEADER, ps);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_READFUNCTION, curl_send_cb);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_READDATA, ps);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_WRITEFUNCTION,
+                        curl_receive_cb);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_READDATA, ps);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_TIMEOUT,
+                        (long) timeout.rel_value);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_PRIVATE, ps);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_CONNECTTIMEOUT,
+                        HTTP_CONNECT_TIMEOUT);
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_BUFFERSIZE,
+                        2 * GNUNET_SERVER_MAX_MESSAGE_SIZE);
 #if CURL_TCP_NODELAY
-          curl_easy_setopt(ps->send_endpoint, CURLOPT_TCP_NODELAY, 1);
-#endif
-          if (fresh==GNUNET_YES)
-            {
-              mret = curl_multi_add_handle(plugin->multi_handle, ps->send_endpoint);
-              if (mret != CURLM_OK)
-                {
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                              _("Connection: %X: %s failed at %s:%d: `%s'\n"),
-                              ps,
-                              "curl_multi_add_handle", __FILE__, __LINE__,
-                              curl_multi_strerror (mret));
-                  return GNUNET_SYSERR;
-                }
-            }
-        }
-      if (plugin->http_curl_task !=  GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
-          plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      plugin->current_connections++;
-      plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
-      return GNUNET_YES;
+      curl_easy_setopt (ps->send_endpoint, CURLOPT_TCP_NODELAY, 1);
+#endif
+      if (fresh == GNUNET_YES)
+      {
+        mret = curl_multi_add_handle (plugin->multi_handle, ps->send_endpoint);
+        if (mret != CURLM_OK)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Connection: %X: %s failed at %s:%d: `%s'\n"),
+                      ps,
+                      "curl_multi_add_handle", __FILE__, __LINE__,
+                      curl_multi_strerror (mret));
+          return GNUNET_SYSERR;
+        }
+      }
     }
-  if (ps->direction == INBOUND)
+    if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_assert (NULL != ps->pending_msgs_tail);
-      if ((ps->recv_connected==GNUNET_YES) && (ps->send_connected==GNUNET_YES) &&
-          (ps->recv_force_disconnect==GNUNET_NO) && (ps->recv_force_disconnect==GNUNET_NO))
-        return GNUNET_YES;
+      GNUNET_SCHEDULER_cancel (plugin->http_curl_task);
+      plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
     }
+    plugin->current_connections++;
+    plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
+    return GNUNET_YES;
+  }
+  if (ps->direction == INBOUND)
+  {
+    GNUNET_assert (NULL != ps->pending_msgs_tail);
+    if ((ps->recv_connected == GNUNET_YES) && (ps->send_connected == GNUNET_YES)
+        && (ps->recv_force_disconnect == GNUNET_NO) &&
+        (ps->recv_force_disconnect == GNUNET_NO))
+      return GNUNET_YES;
+  }
   return GNUNET_SYSERR;
 }
 
@@ -2362,130 +2370,129 @@ send_check_connections (struct Plugin *plugin,
  * @return selected session
  *
  */
-static struct Session * 
-send_select_session (struct HTTP_PeerContext *pc, 
-                     const void * addr, size_t addrlen, 
-                     int force_address, 
-                     struct Session * session)
+static struct Session *
+send_select_session (struct HTTP_PeerContext *pc,
+                     const void *addr, size_t addrlen,
+                     int force_address, struct Session *session)
 {
-  struct Session * tmp = NULL;
+  struct Session *tmp = NULL;
   int addr_given = GNUNET_NO;
-  
-  if ((addr!=NULL) && (addrlen>0))
+
+  if ((addr != NULL) && (addrlen > 0))
     addr_given = GNUNET_YES;
-  
+
   if (force_address == GNUNET_YES)
+  {
+    /* check session given as argument */
+    if ((session != NULL) && (addr_given == GNUNET_YES))
     {
-      /* check session given as argument */
-      if ((session != NULL) && (addr_given == GNUNET_YES))
-        {
-          if (0 == memcmp(session->addr, addr, addrlen))
-            {
-              /* connection can not be used, since it is disconnected */
-              if ( (session->recv_force_disconnect==GNUNET_NO) && 
-                   (session->send_force_disconnect==GNUNET_NO) )
-                {
+      if (0 == memcmp (session->addr, addr, addrlen))
+      {
+        /* connection can not be used, since it is disconnected */
+        if ((session->recv_force_disconnect == GNUNET_NO) &&
+            (session->send_force_disconnect == GNUNET_NO))
+        {
 #if DEBUG_SESSION_SELECTION
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                              "Session %X selected: Using session passed by transport to send to forced address \n", 
-                              session);
-#endif
-                  return session;
-                }
-            }
-        }
-      /* check last session used */
-      if ((pc->last_session != NULL)&& (addr_given == GNUNET_YES))
-        {
-          if (0 == memcmp(pc->last_session->addr, addr, addrlen))
-            {
-              /* connection can not be used, since it is disconnected */
-              if ( (pc->last_session->recv_force_disconnect==GNUNET_NO) && 
-                   (pc->last_session->send_force_disconnect==GNUNET_NO) )
-                {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Session %X selected: Using session passed by transport to send to forced address \n",
+                      session);
+#endif
+          return session;
+        }
+      }
+    }
+    /* check last session used */
+    if ((pc->last_session != NULL) && (addr_given == GNUNET_YES))
+    {
+      if (0 == memcmp (pc->last_session->addr, addr, addrlen))
+      {
+        /* connection can not be used, since it is disconnected */
+        if ((pc->last_session->recv_force_disconnect == GNUNET_NO) &&
+            (pc->last_session->send_force_disconnect == GNUNET_NO))
+        {
 #if DEBUG_SESSION_SELECTION
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                              "Session %X selected: Using last session used to send to forced address \n", 
-                              pc->last_session);
-#endif
-                  return pc->last_session;
-                }
-            }
-        }
-      /* find session in existing sessions */
-      tmp = pc->head;
-      while ((tmp!=NULL) && (addr_given == GNUNET_YES))
-        {
-          if (0 == memcmp(tmp->addr, addr, addrlen))
-            {
-              /* connection can not be used, since it is disconnected */
-              if ( (tmp->recv_force_disconnect==GNUNET_NO) &&
-                   (tmp->send_force_disconnect==GNUNET_NO) )
-                {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Session %X selected: Using last session used to send to forced address \n",
+                      pc->last_session);
+#endif
+          return pc->last_session;
+        }
+      }
+    }
+    /* find session in existing sessions */
+    tmp = pc->head;
+    while ((tmp != NULL) && (addr_given == GNUNET_YES))
+    {
+      if (0 == memcmp (tmp->addr, addr, addrlen))
+      {
+        /* connection can not be used, since it is disconnected */
+        if ((tmp->recv_force_disconnect == GNUNET_NO) &&
+            (tmp->send_force_disconnect == GNUNET_NO))
+        {
 #if DEBUG_SESSION_SELECTION
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                              "Session %X selected: Using existing session to send to forced address \n", 
-                              session);
-#endif
-                  return session;
-                }             
-            }
-          tmp=tmp->next;
-        }
-      /* no session to use */
-      return NULL;
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Session %X selected: Using existing session to send to forced address \n",
+                      session);
+#endif
+          return session;
+        }
+      }
+      tmp = tmp->next;
     }
+    /* no session to use */
+    return NULL;
+  }
   if ((force_address == GNUNET_NO) || (force_address == GNUNET_SYSERR))
+  {
+    /* check session given as argument */
+    if (session != NULL)
     {
-      /* check session given as argument */
-      if (session != NULL)
-        {
-          /* connection can not be used, since it is disconnected */
-          if ( (session->recv_force_disconnect==GNUNET_NO) &&
-               (session->send_force_disconnect==GNUNET_NO) )
-            {
+      /* connection can not be used, since it is disconnected */
+      if ((session->recv_force_disconnect == GNUNET_NO) &&
+          (session->send_force_disconnect == GNUNET_NO))
+      {
 #if DEBUG_SESSION_SELECTION
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Session %X selected: Using session passed by transport to send not-forced address\n", 
-                          session);
-#endif
-              return session;
-            }     
-        }
-      /* check last session used */
-      if (pc->last_session != NULL)
-        {
-          /* connection can not be used, since it is disconnected */
-          if ( (pc->last_session->recv_force_disconnect==GNUNET_NO) &&
-               (pc->last_session->send_force_disconnect==GNUNET_NO) )
-            {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Session %X selected: Using session passed by transport to send not-forced address\n",
+                    session);
+#endif
+        return session;
+      }
+    }
+    /* check last session used */
+    if (pc->last_session != NULL)
+    {
+      /* connection can not be used, since it is disconnected */
+      if ((pc->last_session->recv_force_disconnect == GNUNET_NO) &&
+          (pc->last_session->send_force_disconnect == GNUNET_NO))
+      {
 #if DEBUG_SESSION_SELECTION
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Session %X selected: Using last session to send to not-forced address\n", 
-                          pc->last_session);
-#endif
-              return pc->last_session;
-            }
-        }
-      /* find session in existing sessions */
-      tmp = pc->head;
-      while (tmp!=NULL)
-        {
-          /* connection can not be used, since it is disconnected */
-          if ( (tmp->recv_force_disconnect==GNUNET_NO) && 
-               (tmp->send_force_disconnect==GNUNET_NO) )
-            {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Session %X selected: Using last session to send to not-forced address\n",
+                    pc->last_session);
+#endif
+        return pc->last_session;
+      }
+    }
+    /* find session in existing sessions */
+    tmp = pc->head;
+    while (tmp != NULL)
+    {
+      /* connection can not be used, since it is disconnected */
+      if ((tmp->recv_force_disconnect == GNUNET_NO) &&
+          (tmp->send_force_disconnect == GNUNET_NO))
+      {
 #if DEBUG_SESSION_SELECTION
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Session %X selected: Using existing session to send to not-forced address\n",
-                          tmp);
-#endif
-              return tmp;
-            }
-          tmp=tmp->next;
-        }
-      return NULL;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Session %X selected: Using existing session to send to not-forced address\n",
+                    tmp);
+#endif
+        return tmp;
+      }
+      tmp = tmp->next;
     }
+    return NULL;
+  }
   return NULL;
 }
 
@@ -2537,117 +2544,112 @@ http_plugin_send (void *cls,
                   const void *addr,
                   size_t addrlen,
                   int force_address,
-                  GNUNET_TRANSPORT_TransmitContinuation cont,
-                  void *cont_cls)
+                  GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
   struct Plugin *plugin = cls;
   struct HTTP_Message *msg;
-  struct HTTP_PeerContext * pc;
-  struct Session * ps = NULL;
+  struct HTTP_PeerContext *pc;
+  struct Session *ps = NULL;
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
 
 #if DEBUG_HTTP
-  char * force;
+  char *force;
 
   if (force_address == GNUNET_YES)
-    GNUNET_asprintf(&force, "forced addr.");
+    GNUNET_asprintf (&force, "forced addr.");
   else if (force_address == GNUNET_NO)
-    GNUNET_asprintf(&force, "any addr.");
+    GNUNET_asprintf (&force, "any addr.");
   else if (force_address == GNUNET_SYSERR)
-    GNUNET_asprintf(&force,"reliable bi-direc. address addr.");
+    GNUNET_asprintf (&force, "reliable bi-direc. address addr.");
   else
     GNUNET_assert (0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transport tells me to send %u bytes to `%s' using %s (%s) and session: %X\n",
-              msgbuf_size,
-              GNUNET_i2s(target),
-              force,
-              http_plugin_address_to_string(NULL, addr, addrlen),
-              session);
-  GNUNET_free(force);
+              "Transport tells me to send %u bytes to `%s' using %s (%s) and session: %X\n",
+              msgbuf_size,
+              GNUNET_i2s (target),
+              force,
+              http_plugin_address_to_string (NULL, addr, addrlen), session);
+  GNUNET_free (force);
 #endif
 
   pc = GNUNET_CONTAINER_multihashmap_get (plugin->peers, &target->hashPubKey);
   /* Peer unknown */
-  if (pc==NULL)
-    {
-      pc = GNUNET_malloc(sizeof (struct HTTP_PeerContext));
-      pc->plugin = plugin;
-      pc->session_id_counter=1;
-      pc->last_session = NULL;
-      memcpy(&pc->identity, target, sizeof(struct GNUNET_PeerIdentity));
-      GNUNET_CONTAINER_multihashmap_put (plugin->peers, 
-                                         &pc->identity.hashPubKey, 
-                                         pc, 
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
-      GNUNET_STATISTICS_update (plugin->env->stats,
-                                gettext_noop ("# HTTP peers active"),
-                                1,
-                                GNUNET_NO);
-    }
+  if (pc == NULL)
+  {
+    pc = GNUNET_malloc (sizeof (struct HTTP_PeerContext));
+    pc->plugin = plugin;
+    pc->session_id_counter = 1;
+    pc->last_session = NULL;
+    memcpy (&pc->identity, target, sizeof (struct GNUNET_PeerIdentity));
+    GNUNET_CONTAINER_multihashmap_put (plugin->peers,
+                                       &pc->identity.hashPubKey,
+                                       pc,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+    GNUNET_STATISTICS_update (plugin->env->stats,
+                              gettext_noop ("# HTTP peers active"),
+                              1, GNUNET_NO);
+  }
   ps = send_select_session (pc, addr, addrlen, force_address, session);
   /* session not existing, but address forced -> creating new session */
-  if (ps==NULL)
+  if (ps == NULL)
+  {
+    if ((addr != NULL) && (addrlen != 0))
     {
-      if ((addr!=NULL) && (addrlen!=0))
-        {
-          ps = GNUNET_malloc(sizeof (struct Session));
+      ps = GNUNET_malloc (sizeof (struct Session));
 #if DEBUG_SESSION_SELECTION
-          if (force_address == GNUNET_YES)
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                        "No existing connection & forced address: creating new session %X to peer %s\n", 
-                        ps, GNUNET_i2s(target));
-          if (force_address != GNUNET_YES)
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                        "No existing connection: creating new session %X to peer %s\n", 
-                        ps, GNUNET_i2s(target));
-#endif
-          ps->addr = GNUNET_malloc(addrlen);
-          memcpy(ps->addr,addr,addrlen);
-          ps->addrlen = addrlen;
-          ps->direction=OUTBOUND;
-          ps->recv_connected = GNUNET_NO;
-          ps->recv_force_disconnect = GNUNET_NO;
-          ps->send_connected = GNUNET_NO;
-          ps->send_force_disconnect = GNUNET_NO;
-          ps->pending_msgs_head = NULL;
-          ps->pending_msgs_tail = NULL;
-          ps->peercontext = pc;
-          ps->session_id = pc->session_id_counter;
-          ps->queue_length_cur = 0;
-          ps->queue_length_max = GNUNET_SERVER_MAX_MESSAGE_SIZE;
-          pc->session_id_counter++;
-          ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
-          if (ps->msgtok == NULL)
-            ps->msgtok = GNUNET_SERVER_mst_create (&curl_receive_mst_cb, ps);
-          GNUNET_CONTAINER_DLL_insert(pc->head,pc->tail,ps);
-          GNUNET_STATISTICS_update (plugin->env->stats,
-                                    gettext_noop ("# HTTP outbound sessions for peers active"),
-                                    1,
-                                    GNUNET_NO);
-        }
-      else
-        {
-#if DEBUG_HTTP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "No existing session found & and no address given: no way to send this message to peer `%s'!\n", 
-                      GNUNET_i2s(target));
+      if (force_address == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "No existing connection & forced address: creating new session %X to peer %s\n",
+                    ps, GNUNET_i2s (target));
+      if (force_address != GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "No existing connection: creating new session %X to peer %s\n",
+                    ps, GNUNET_i2s (target));
 #endif
-          return GNUNET_SYSERR;
-        }
+      ps->addr = GNUNET_malloc (addrlen);
+      memcpy (ps->addr, addr, addrlen);
+      ps->addrlen = addrlen;
+      ps->direction = OUTBOUND;
+      ps->recv_connected = GNUNET_NO;
+      ps->recv_force_disconnect = GNUNET_NO;
+      ps->send_connected = GNUNET_NO;
+      ps->send_force_disconnect = GNUNET_NO;
+      ps->pending_msgs_head = NULL;
+      ps->pending_msgs_tail = NULL;
+      ps->peercontext = pc;
+      ps->session_id = pc->session_id_counter;
+      ps->queue_length_cur = 0;
+      ps->queue_length_max = GNUNET_SERVER_MAX_MESSAGE_SIZE;
+      pc->session_id_counter++;
+      ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
+      if (ps->msgtok == NULL)
+        ps->msgtok = GNUNET_SERVER_mst_create (&curl_receive_mst_cb, ps);
+      GNUNET_CONTAINER_DLL_insert (pc->head, pc->tail, ps);
+      GNUNET_STATISTICS_update (plugin->env->stats,
+                                gettext_noop
+                                ("# HTTP outbound sessions for peers active"),
+                                1, GNUNET_NO);
     }
-  
-  if (msgbuf_size >= (ps->queue_length_max - ps->queue_length_cur))
+    else
     {
+#if DEBUG_HTTP
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Queue %X full: %u bytes in queue available, message with %u is too big\n", 
-                  ps, 
-                  (ps->queue_length_max - ps->queue_length_cur), 
-                  msgbuf_size);
-      //return GNUNET_SYSERR;
+                  "No existing session found & and no address given: no way to send this message to peer `%s'!\n",
+                  GNUNET_i2s (target));
+#endif
+      return GNUNET_SYSERR;
     }
-  
+  }
+
+  if (msgbuf_size >= (ps->queue_length_max - ps->queue_length_cur))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Queue %X full: %u bytes in queue available, message with %u is too big\n",
+                ps, (ps->queue_length_max - ps->queue_length_cur), msgbuf_size);
+    //return GNUNET_SYSERR;
+  }
+
   /* create msg */
   msg = GNUNET_malloc (sizeof (struct HTTP_Message) + msgbuf_size);
   msg->next = NULL;
@@ -2656,16 +2658,15 @@ http_plugin_send (void *cls,
   msg->buf = (char *) &msg[1];
   msg->transmit_cont = cont;
   msg->transmit_cont_cls = cont_cls;
-  memcpy (msg->buf,msgbuf, msgbuf_size);  
+  memcpy (msg->buf, msgbuf, msgbuf_size);
   GNUNET_CONTAINER_DLL_insert (ps->pending_msgs_head,
-                               ps->pending_msgs_tail,
-                               msg);
+                               ps->pending_msgs_tail, msg);
   ps->queue_length_cur += msgbuf_size;
   if (send_check_connections (plugin, ps) == GNUNET_SYSERR)
     return GNUNET_SYSERR;
   if (force_address != GNUNET_YES)
     pc->last_session = ps;
-  if (pc->last_session==NULL)
+  if (pc->last_session == NULL)
     pc->last_session = ps;
   return msg->size;
 }
@@ -2680,49 +2681,48 @@ http_plugin_send (void *cls,
  * @param target peer from which to disconnect
  */
 static void
-http_plugin_disconnect (void *cls,
-                            const struct GNUNET_PeerIdentity *target)
+http_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
 {
   struct Plugin *plugin = cls;
   struct HTTP_PeerContext *pc = NULL;
   struct Session *ps = NULL;
 
   pc = GNUNET_CONTAINER_multihashmap_get (plugin->peers, &target->hashPubKey);
-  if (pc==NULL)
+  if (pc == NULL)
     return;
   ps = pc->head;
-  while (ps!=NULL)
+  while (ps != NULL)
+  {
+    /* Telling transport that session is getting disconnected */
+    plugin->env->session_end (plugin, target, ps);
+    if (ps->direction == OUTBOUND)
     {
-      /* Telling transport that session is getting disconnected */
-      plugin->env->session_end(plugin, target, ps);
-      if (ps->direction==OUTBOUND)
-        {
-          if (ps->send_endpoint!=NULL)
-            {
-              //GNUNET_assert(CURLM_OK == curl_multi_remove_handle(plugin->multi_handle,ps->send_endpoint));
-              //curl_easy_cleanup(ps->send_endpoint);
-              //ps->send_endpoint=NULL;
-              ps->send_force_disconnect = GNUNET_YES;
-            }
-          if (ps->recv_endpoint!=NULL)
-            {
-              //GNUNET_assert(CURLM_OK == curl_multi_remove_handle(plugin->multi_handle,ps->recv_endpoint));
-              //curl_easy_cleanup(ps->recv_endpoint);
-              //ps->recv_endpoint=NULL;
-              ps->recv_force_disconnect = GNUNET_YES;
-            }
-        }
-      if (ps->direction==INBOUND)
-        {
-          ps->recv_force_disconnect = GNUNET_YES;
-          ps->send_force_disconnect = GNUNET_YES;
-        }      
-      while (ps->pending_msgs_head!=NULL)
-        remove_http_message(ps, ps->pending_msgs_head);
-      ps->recv_active = GNUNET_NO;
-      ps->send_active = GNUNET_NO;
-      ps=ps->next;
+      if (ps->send_endpoint != NULL)
+      {
+        //GNUNET_assert(CURLM_OK == curl_multi_remove_handle(plugin->multi_handle,ps->send_endpoint));
+        //curl_easy_cleanup(ps->send_endpoint);
+        //ps->send_endpoint=NULL;
+        ps->send_force_disconnect = GNUNET_YES;
+      }
+      if (ps->recv_endpoint != NULL)
+      {
+        //GNUNET_assert(CURLM_OK == curl_multi_remove_handle(plugin->multi_handle,ps->recv_endpoint));
+        //curl_easy_cleanup(ps->recv_endpoint);
+        //ps->recv_endpoint=NULL;
+        ps->recv_force_disconnect = GNUNET_YES;
+      }
     }
+    if (ps->direction == INBOUND)
+    {
+      ps->recv_force_disconnect = GNUNET_YES;
+      ps->send_force_disconnect = GNUNET_YES;
+    }
+    while (ps->pending_msgs_head != NULL)
+      remove_http_message (ps, ps->pending_msgs_head);
+    ps->recv_active = GNUNET_NO;
+    ps->send_active = GNUNET_NO;
+    ps = ps->next;
+  }
 }
 
 
@@ -2739,11 +2739,11 @@ append_port (void *cls, const char *hostname)
   char *ret;
 
   if (hostname == NULL)
-    {
-      ppc->asc (ppc->asc_cls, NULL);
-      GNUNET_free (ppc);
-      return;
-    }
+  {
+    ppc->asc (ppc->asc_cls, NULL);
+    GNUNET_free (ppc);
+    return;
+  }
   GNUNET_asprintf (&ret, "%s://%s:%d", PROTOCOL_PREFIX, hostname, ppc->port);
 
   ppc->asc (ppc->asc_cls, ret);
@@ -2768,61 +2768,57 @@ append_port (void *cls, const char *hostname)
  */
 static void
 http_plugin_address_pretty_printer (void *cls,
-                                        const char *type,
-                                        const void *addr,
-                                        size_t addrlen,
-                                        int numeric,
-                                        struct GNUNET_TIME_Relative timeout,
-                                        GNUNET_TRANSPORT_AddressStringCallback
-                                        asc, void *asc_cls)
+                                    const char *type,
+                                    const void *addr,
+                                    size_t addrlen,
+                                    int numeric,
+                                    struct GNUNET_TIME_Relative timeout,
+                                    GNUNET_TRANSPORT_AddressStringCallback
+                                    asc, void *asc_cls)
 {
   struct PrettyPrinterContext *ppc;
   const void *sb;
   size_t sbs;
-  struct sockaddr_in  a4;
+  struct sockaddr_in a4;
   struct sockaddr_in6 a6;
   const struct IPv4HttpAddress *t4;
   const struct IPv6HttpAddress *t6;
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6HttpAddress))
-    {
-      t6 = addr;
-      memset (&a6, 0, sizeof (a6));
-      a6.sin6_family = AF_INET6;
-      a6.sin6_port = t6->port;
-      memcpy (&a6.sin6_addr,
-              &t6->ipv6_addr,
-              sizeof (struct in6_addr));
-      port = ntohs (t6->port);
-      sb = &a6;
-      sbs = sizeof (a6);
-    }
+  {
+    t6 = addr;
+    memset (&a6, 0, sizeof (a6));
+    a6.sin6_family = AF_INET6;
+    a6.sin6_port = t6->port;
+    memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof (struct in6_addr));
+    port = ntohs (t6->port);
+    sb = &a6;
+    sbs = sizeof (a6);
+  }
   else if (addrlen == sizeof (struct IPv4HttpAddress))
-    {
-      t4 = addr;
-      memset (&a4, 0, sizeof (a4));
-      a4.sin_family = AF_INET;
-      a4.sin_port = t4->port;
-      a4.sin_addr.s_addr = t4->ipv4_addr;
-      port = ntohs (t4->ipv4_addr);
-      sb = &a4;
-      sbs = sizeof (a4);
-    }
+  {
+    t4 = addr;
+    memset (&a4, 0, sizeof (a4));
+    a4.sin_family = AF_INET;
+    a4.sin_port = t4->port;
+    a4.sin_addr.s_addr = t4->ipv4_addr;
+    port = ntohs (t4->ipv4_addr);
+    sb = &a4;
+    sbs = sizeof (a4);
+  }
   else
-    {
-      /* invalid address */
-      GNUNET_break_op (0);
-      asc (asc_cls, NULL);
-      return;
-    }
+  {
+    /* invalid address */
+    GNUNET_break_op (0);
+    asc (asc_cls, NULL);
+    return;
+  }
   ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext));
   ppc->asc = asc;
   ppc->asc_cls = asc_cls;
   ppc->port = port;
-  GNUNET_RESOLVER_hostname_get (sb,
-                                sbs,
-                                !numeric, timeout, &append_port, ppc);
+  GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
 }
 
 
@@ -2840,8 +2836,7 @@ http_plugin_address_pretty_printer (void *cls,
  *         and transport
  */
 static int
-http_plugin_address_suggested (void *cls,
-                               const void *addr, size_t addrlen)
+http_plugin_address_suggested (void *cls, const void *addr, size_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct IPv4HttpAddress *v4;
@@ -2849,52 +2844,59 @@ http_plugin_address_suggested (void *cls,
   struct IPv4HttpAddressWrapper *w_tv4 = plugin->ipv4_addr_head;
   struct IPv6HttpAddressWrapper *w_tv6 = plugin->ipv6_addr_head;
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
   if ((addrlen != sizeof (struct IPv4HttpAddress)) &&
       (addrlen != sizeof (struct IPv6HttpAddress)))
     return GNUNET_SYSERR;
   if (addrlen == sizeof (struct IPv4HttpAddress))
+  {
+    v4 = (struct IPv4HttpAddress *) addr;
+    if (plugin->bind4_address != NULL)
     {
-      v4 = (struct IPv4HttpAddress *) addr;
-      if (plugin->bind4_address!=NULL)
-        {
-          if (0 == memcmp (&plugin->bind4_address->sin_addr, &v4->ipv4_addr, sizeof(uint32_t)))
-            return GNUNET_OK;
-          else
-            return GNUNET_SYSERR;
-        }
-      while (w_tv4!=NULL)
-        {
-          if (0==memcmp (&w_tv4->addr->ipv4_addr, &v4->ipv4_addr, sizeof(uint32_t)))
-            break;
-          w_tv4 = w_tv4->next;
-        }
-      if (w_tv4 != NULL)
+      if (0 ==
+          memcmp (&plugin->bind4_address->sin_addr, &v4->ipv4_addr,
+                  sizeof (uint32_t)))
         return GNUNET_OK;
       else
-        return GNUNET_SYSERR;
+        return GNUNET_SYSERR;
+    }
+    while (w_tv4 != NULL)
+    {
+      if (0 ==
+          memcmp (&w_tv4->addr->ipv4_addr, &v4->ipv4_addr, sizeof (uint32_t)))
+        break;
+      w_tv4 = w_tv4->next;
     }
+    if (w_tv4 != NULL)
+      return GNUNET_OK;
+    else
+      return GNUNET_SYSERR;
+  }
   if (addrlen == sizeof (struct IPv6HttpAddress))
+  {
+    v6 = (struct IPv6HttpAddress *) addr;
+    if (plugin->bind6_address != NULL)
     {
-      v6 = (struct IPv6HttpAddress *) addr;
-      if (plugin->bind6_address!=NULL)
-        {
-          if (0 == memcmp (&plugin->bind6_address->sin6_addr, &v6->ipv6_addr, sizeof(struct in6_addr)))
-            return GNUNET_OK;
-          else
-            return GNUNET_SYSERR;
-        }
-      while (w_tv6!=NULL)
-        {
-          if (0 == memcmp (&w_tv6->addr->ipv6_addr, &v6->ipv6_addr, sizeof(struct in6_addr)))
-            break;
-          w_tv6 = w_tv6->next;
-        }
-      if (w_tv6 !=NULL)
+      if (0 ==
+          memcmp (&plugin->bind6_address->sin6_addr, &v6->ipv6_addr,
+                  sizeof (struct in6_addr)))
         return GNUNET_OK;
       else
-        return GNUNET_SYSERR;
+        return GNUNET_SYSERR;
+    }
+    while (w_tv6 != NULL)
+    {
+      if (0 ==
+          memcmp (&w_tv6->addr->ipv6_addr, &v6->ipv6_addr,
+                  sizeof (struct in6_addr)))
+        break;
+      w_tv6 = w_tv6->next;
     }
+    if (w_tv6 != NULL)
+      return GNUNET_OK;
+    else
+      return GNUNET_SYSERR;
+  }
   return GNUNET_SYSERR;
 }
 
@@ -2910,50 +2912,44 @@ http_plugin_address_suggested (void *cls,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-http_plugin_address_to_string (void *cls,
-                                   const void *addr,
-                                   size_t addrlen)
+static const char *
+http_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   const struct IPv4HttpAddress *t4;
   const struct IPv6HttpAddress *t6;
   struct sockaddr_in a4;
   struct sockaddr_in6 a6;
-  char * address;
+  char *address;
   static char rbuf[INET6_ADDRSTRLEN + 13];
   uint16_t port;
   int res;
 
   if (addrlen == sizeof (struct IPv6HttpAddress))
-    {
-      address = GNUNET_malloc (INET6_ADDRSTRLEN);
-      t6 = addr;
-      a6.sin6_addr = t6->ipv6_addr;
-      inet_ntop(AF_INET6, &(a6.sin6_addr),address,INET6_ADDRSTRLEN);
-      port = ntohs(t6->port);
-    }
+  {
+    address = GNUNET_malloc (INET6_ADDRSTRLEN);
+    t6 = addr;
+    a6.sin6_addr = t6->ipv6_addr;
+    inet_ntop (AF_INET6, &(a6.sin6_addr), address, INET6_ADDRSTRLEN);
+    port = ntohs (t6->port);
+  }
   else if (addrlen == sizeof (struct IPv4HttpAddress))
-    {
-      address = GNUNET_malloc (INET_ADDRSTRLEN);
-      t4 = addr;
-      a4.sin_addr.s_addr =  t4->ipv4_addr;
-      inet_ntop(AF_INET, &(a4.sin_addr),address,INET_ADDRSTRLEN);
-      port = ntohs(t4->port);
-    }
+  {
+    address = GNUNET_malloc (INET_ADDRSTRLEN);
+    t4 = addr;
+    a4.sin_addr.s_addr = t4->ipv4_addr;
+    inet_ntop (AF_INET, &(a4.sin_addr), address, INET_ADDRSTRLEN);
+    port = ntohs (t4->port);
+  }
   else
-    {
-      /* invalid address */
-      return NULL;
-    }
+  {
+    /* invalid address */
+    return NULL;
+  }
 
-  res = GNUNET_snprintf (rbuf,
-                   sizeof (rbuf),
-                   "%s:%u",
-                   address,
-                   port);
+  res = GNUNET_snprintf (rbuf, sizeof (rbuf), "%s:%u", address, port);
 
   GNUNET_free (address);
-  GNUNET_assert(res != 0);
+  GNUNET_assert (res != 0);
   return rbuf;
 }
 
@@ -2968,23 +2964,21 @@ http_plugin_address_to_string (void *cls,
  */
 static void
 try_connection_reversal (void *cls,
-                         const struct sockaddr *addr,
-                         socklen_t addrlen)
+                         const struct sockaddr *addr, socklen_t addrlen)
 {
 
 }
 
 static void
 tcp_nat_cb_add_addr (void *cls,
-                         int add_remove,
-                         const struct sockaddr *addr,
-                         socklen_t addrlen)
+                     int add_remove,
+                     const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
-  struct IPv4HttpAddress * t4 = NULL;
-  struct IPv4HttpAddressWrapper * w_t4 = NULL;
-  struct IPv6HttpAddress * t6 = NULL;
-  struct IPv6HttpAddressWrapper * w_t6 = NULL;
+  struct IPv4HttpAddress *t4 = NULL;
+  struct IPv4HttpAddressWrapper *w_t4 = NULL;
+  struct IPv6HttpAddress *t6 = NULL;
+  struct IPv6HttpAddressWrapper *w_t6 = NULL;
   int af;
 
   af = addr->sa_family;
@@ -2994,61 +2988,63 @@ tcp_nat_cb_add_addr (void *cls,
     w_t4 = plugin->ipv4_addr_head;
     while (w_t4 != NULL)
     {
-      int res = memcmp(&w_t4->addr->ipv4_addr,
-                       &((struct sockaddr_in *) addr)->sin_addr,
-                       sizeof (struct in_addr));
+      int res = memcmp (&w_t4->addr->ipv4_addr,
+                        &((struct sockaddr_in *) addr)->sin_addr,
+                        sizeof (struct in_addr));
+
       if (0 == res)
         break;
       w_t4 = w_t4->next;
     }
     if (w_t4 == NULL)
     {
-      w_t4 = GNUNET_malloc(sizeof(struct IPv4HttpAddressWrapper));
-      t4 = GNUNET_malloc(sizeof(struct IPv4HttpAddress));
+      w_t4 = GNUNET_malloc (sizeof (struct IPv4HttpAddressWrapper));
+      t4 = GNUNET_malloc (sizeof (struct IPv4HttpAddress));
       memcpy (&t4->ipv4_addr,
-            &((struct sockaddr_in *) addr)->sin_addr,
-            sizeof (struct in_addr));
+              &((struct sockaddr_in *) addr)->sin_addr,
+              sizeof (struct in_addr));
       t4->port = htons (plugin->port_inbound);
 
       w_t4->addr = t4;
 
-      GNUNET_CONTAINER_DLL_insert(plugin->ipv4_addr_head,
-                                  plugin->ipv4_addr_tail,w_t4);
+      GNUNET_CONTAINER_DLL_insert (plugin->ipv4_addr_head,
+                                   plugin->ipv4_addr_tail, w_t4);
     }
-    plugin->env->notify_address(plugin->env->cls,
-                                add_remove,
-                                w_t4->addr, sizeof (struct IPv4HttpAddress));
+    plugin->env->notify_address (plugin->env->cls,
+                                 add_remove,
+                                 w_t4->addr, sizeof (struct IPv4HttpAddress));
 
     break;
   case AF_INET6:
     w_t6 = plugin->ipv6_addr_head;
     while (w_t6)
     {
-      int res = memcmp(&w_t6->addr->ipv6_addr,
-                       &((struct sockaddr_in6 *) addr)->sin6_addr,
-                       sizeof (struct in6_addr));
+      int res = memcmp (&w_t6->addr->ipv6_addr,
+                        &((struct sockaddr_in6 *) addr)->sin6_addr,
+                        sizeof (struct in6_addr));
+
       if (0 == res)
         break;
       w_t6 = w_t6->next;
     }
     if (w_t6 == NULL)
     {
-    w_t6 = GNUNET_malloc(sizeof(struct IPv6HttpAddressWrapper));
-    t6 = GNUNET_malloc(sizeof(struct IPv6HttpAddress));
+      w_t6 = GNUNET_malloc (sizeof (struct IPv6HttpAddressWrapper));
+      t6 = GNUNET_malloc (sizeof (struct IPv6HttpAddress));
 
-    memcpy (&t6->ipv6_addr,
-            &((struct sockaddr_in6 *) addr)->sin6_addr,
-            sizeof (struct in6_addr));
-    t6->port = htons (plugin->port_inbound);
+      memcpy (&t6->ipv6_addr,
+              &((struct sockaddr_in6 *) addr)->sin6_addr,
+              sizeof (struct in6_addr));
+      t6->port = htons (plugin->port_inbound);
 
-    w_t6->addr = t6;
+      w_t6->addr = t6;
 
-    GNUNET_CONTAINER_DLL_insert(plugin->ipv6_addr_head,
-                                plugin->ipv6_addr_tail,w_t6);
+      GNUNET_CONTAINER_DLL_insert (plugin->ipv6_addr_head,
+                                   plugin->ipv6_addr_tail, w_t6);
     }
-    plugin->env->notify_address(plugin->env->cls,
-                                add_remove,
-                                w_t6->addr, sizeof (struct IPv6HttpAddress));
+    plugin->env->notify_address (plugin->env->cls,
+                                 add_remove,
+                                 w_t6->addr, sizeof (struct IPv6HttpAddress));
     break;
   default:
     return;
@@ -3058,13 +3054,12 @@ tcp_nat_cb_add_addr (void *cls,
 
 static void
 tcp_nat_cb_remove_addr (void *cls,
-                         int add_remove,
-                         const struct sockaddr *addr,
-                         socklen_t addrlen)
+                        int add_remove,
+                        const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
-  struct IPv4HttpAddressWrapper * w_t4 = NULL;
-  struct IPv6HttpAddressWrapper * w_t6 = NULL;
+  struct IPv4HttpAddressWrapper *w_t4 = NULL;
+  struct IPv6HttpAddressWrapper *w_t6 = NULL;
   int af;
 
   af = addr->sa_family;
@@ -3072,45 +3067,47 @@ tcp_nat_cb_remove_addr (void *cls,
   {
   case AF_INET:
     w_t4 = plugin->ipv4_addr_head;
-      while (w_t4 != NULL)
-      {
-        int res = memcmp(&w_t4->addr->ipv4_addr,
-                         &((struct sockaddr_in *) addr)->sin_addr,
-                         sizeof (struct in_addr));
-        if (0 == res)
-          break;
-        w_t4 = w_t4->next;
-      }
-      if (w_t4 == NULL)
-        return;
-      plugin->env->notify_address(plugin->env->cls,
-                                add_remove,
-                                w_t4->addr, sizeof (struct IPv4HttpAddress));
-
-      GNUNET_CONTAINER_DLL_remove(plugin->ipv4_addr_head,
-                                  plugin->ipv4_addr_tail,w_t4);
-      GNUNET_free (w_t4->addr);
-      GNUNET_free (w_t4);
+    while (w_t4 != NULL)
+    {
+      int res = memcmp (&w_t4->addr->ipv4_addr,
+                        &((struct sockaddr_in *) addr)->sin_addr,
+                        sizeof (struct in_addr));
+
+      if (0 == res)
+        break;
+      w_t4 = w_t4->next;
+    }
+    if (w_t4 == NULL)
+      return;
+    plugin->env->notify_address (plugin->env->cls,
+                                 add_remove,
+                                 w_t4->addr, sizeof (struct IPv4HttpAddress));
+
+    GNUNET_CONTAINER_DLL_remove (plugin->ipv4_addr_head,
+                                 plugin->ipv4_addr_tail, w_t4);
+    GNUNET_free (w_t4->addr);
+    GNUNET_free (w_t4);
     break;
   case AF_INET6:
     w_t6 = plugin->ipv6_addr_head;
     while (w_t6 != NULL)
     {
-      int res = memcmp(&w_t6->addr->ipv6_addr,
-                       &((struct sockaddr_in6 *) addr)->sin6_addr,
-                       sizeof (struct in6_addr));
+      int res = memcmp (&w_t6->addr->ipv6_addr,
+                        &((struct sockaddr_in6 *) addr)->sin6_addr,
+                        sizeof (struct in6_addr));
+
       if (0 == res)
         break;
       w_t6 = w_t6->next;
     }
     if (w_t6 == NULL)
       return;
-    plugin->env->notify_address(plugin->env->cls,
-                              add_remove,
-                              w_t6->addr, sizeof (struct IPv6HttpAddress));
+    plugin->env->notify_address (plugin->env->cls,
+                                 add_remove,
+                                 w_t6->addr, sizeof (struct IPv6HttpAddress));
 
-    GNUNET_CONTAINER_DLL_remove(plugin->ipv6_addr_head,
-                                plugin->ipv6_addr_tail,w_t6);
+    GNUNET_CONTAINER_DLL_remove (plugin->ipv6_addr_head,
+                                 plugin->ipv6_addr_tail, w_t6);
     GNUNET_free (w_t6->addr);
     GNUNET_free (w_t6);
     break;
@@ -3132,10 +3129,9 @@ tcp_nat_cb_remove_addr (void *cls,
 static void
 tcp_nat_port_map_callback (void *cls,
                            int add_remove,
-                           const struct sockaddr *addr,
-                           socklen_t addrlen)
+                           const struct sockaddr *addr, socklen_t addrlen)
 {
-  GNUNET_assert(cls !=NULL );
+  GNUNET_assert (cls != NULL);
 #if DEBUG_HTTP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                    "NPMC called to %s address `%s'\n",
@@ -3163,74 +3159,77 @@ LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls)
   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
   struct Plugin *plugin = api->cls;
   CURLMcode mret;
-  struct IPv4HttpAddressWrapper * w_t4;
-  struct IPv6HttpAddressWrapper * w_t6;
-  GNUNET_assert(cls !=NULL);
+  struct IPv4HttpAddressWrapper *w_t4;
+  struct IPv6HttpAddressWrapper *w_t6;
+
+  GNUNET_assert (cls != NULL);
 
   if (plugin->nat != NULL)
     GNUNET_NAT_unregister (plugin->nat);
 
   if (plugin->http_server_daemon_v4 != NULL)
-    {
-      MHD_stop_daemon (plugin->http_server_daemon_v4);
-      plugin->http_server_daemon_v4 = NULL;
-    }
+  {
+    MHD_stop_daemon (plugin->http_server_daemon_v4);
+    plugin->http_server_daemon_v4 = NULL;
+  }
   if (plugin->http_server_daemon_v6 != NULL)
-    {
-      MHD_stop_daemon (plugin->http_server_daemon_v6);
-      plugin->http_server_daemon_v6 = NULL;
-    }
-  if ( plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->http_server_task_v4);
-      plugin->http_server_task_v4 = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if ( plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->http_server_task_v6);
-      plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    MHD_stop_daemon (plugin->http_server_daemon_v6);
+    plugin->http_server_daemon_v6 = NULL;
+  }
+  if (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (plugin->http_server_task_v4);
+    plugin->http_server_task_v4 = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (plugin->http_server_task_v6);
+    plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
+  }
+
+  while (plugin->ipv4_addr_head != NULL)
+  {
+    w_t4 = plugin->ipv4_addr_head;
+    GNUNET_CONTAINER_DLL_remove (plugin->ipv4_addr_head, plugin->ipv4_addr_tail,
+                                 w_t4);
+    GNUNET_free (w_t4->addr);
+    GNUNET_free (w_t4);
+  }
+
+  while (plugin->ipv6_addr_head != NULL)
+  {
+    w_t6 = plugin->ipv6_addr_head;
+    GNUNET_CONTAINER_DLL_remove (plugin->ipv6_addr_head, plugin->ipv6_addr_tail,
+                                 w_t6);
+    GNUNET_free (w_t6->addr);
+    GNUNET_free (w_t6);
+  }
 
-  while (plugin->ipv4_addr_head!=NULL)
-    {
-      w_t4 = plugin->ipv4_addr_head;
-      GNUNET_CONTAINER_DLL_remove(plugin->ipv4_addr_head,plugin->ipv4_addr_tail,w_t4);
-      GNUNET_free(w_t4->addr);
-      GNUNET_free(w_t4);
-    }
-  
-  while (plugin->ipv6_addr_head!=NULL)
-    {
-      w_t6 = plugin->ipv6_addr_head;
-      GNUNET_CONTAINER_DLL_remove(plugin->ipv6_addr_head,plugin->ipv6_addr_tail,w_t6);
-      GNUNET_free(w_t6->addr);
-      GNUNET_free(w_t6);
-    }
-  
   /* free all peer information */
-  if (plugin->peers!=NULL)
-    {
-      GNUNET_CONTAINER_multihashmap_iterate (plugin->peers,
-                                             &remove_peer_context_Iterator,
-                                             plugin);
-      GNUNET_CONTAINER_multihashmap_destroy (plugin->peers);
-    }
-  if (plugin->multi_handle!=NULL)
-    {
-      mret = curl_multi_cleanup(plugin->multi_handle);
-      if (CURLM_OK != mret)
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    "curl multihandle clean up failed\n");
-      plugin->multi_handle = NULL;
-    }
-  curl_global_cleanup();
-  
-  if ( plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
-      plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  
+  if (plugin->peers != NULL)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (plugin->peers,
+                                           &remove_peer_context_Iterator,
+                                           plugin);
+    GNUNET_CONTAINER_multihashmap_destroy (plugin->peers);
+  }
+  if (plugin->multi_handle != NULL)
+  {
+    mret = curl_multi_cleanup (plugin->multi_handle);
+    if (CURLM_OK != mret)
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "curl multihandle clean up failed\n");
+    plugin->multi_handle = NULL;
+  }
+  curl_global_cleanup ();
+
+  if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (plugin->http_curl_task);
+    plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+
 
   GNUNET_free_non_null (plugin->bind4_address);
   GNUNET_free_non_null (plugin->bind6_address);
@@ -3244,35 +3243,36 @@ LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls)
   GNUNET_free (api);
 #if DEBUG_HTTP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Unload %s plugin complete...\n", 
-              PROTOCOL_PREFIX);
+              "Unload %s plugin complete...\n", PROTOCOL_PREFIX);
 #endif
   return NULL;
 }
 
 #if BUILD_HTTPS
 static char *
-load_certificate( const char * file )
+load_certificate (const char *file)
 {
-  struct GNUNET_DISK_FileHandle * gn_file;
+  struct GNUNET_DISK_FileHandle *gn_file;
   struct stat fstat;
-  char * text = NULL;
+  char *text = NULL;
 
-  if (0 != STAT(file, &fstat))
+  if (0 != STAT (file, &fstat))
     return NULL;
-  text = GNUNET_malloc (fstat.st_size+1);
-  gn_file = GNUNET_DISK_file_open(file, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_USER_READ);
-  if (gn_file==NULL)
-    {
-      GNUNET_free(text);
-      return NULL;
-    }
+  text = GNUNET_malloc (fstat.st_size + 1);
+  gn_file =
+      GNUNET_DISK_file_open (file, GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_USER_READ);
+  if (gn_file == NULL)
+  {
+    GNUNET_free (text);
+    return NULL;
+  }
   if (GNUNET_SYSERR == GNUNET_DISK_file_read (gn_file, text, fstat.st_size))
-    {
-      GNUNET_free (text);
-      GNUNET_DISK_file_close (gn_file);
-      return NULL;
-    }
+  {
+    GNUNET_free (text);
+    GNUNET_DISK_file_close (gn_file);
+    return NULL;
+  }
   text[fstat.st_size] = '\0';
   GNUNET_DISK_file_close (gn_file);
   return text;
@@ -3295,21 +3295,19 @@ LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
   struct sockaddr **addrs;
   socklen_t *addrlens;
   int ret;
-  char * component_name;
+  char *component_name;
+
 #if BUILD_HTTPS
-  char * key_file = NULL;
-  char * cert_file = NULL;
+  char *key_file = NULL;
+  char *cert_file = NULL;
 #endif
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
 #if DEBUG_HTTP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting %s plugin...\n", 
-              PROTOCOL_PREFIX);
+              "Starting %s plugin...\n", PROTOCOL_PREFIX);
 #endif
-  GNUNET_asprintf(&component_name,
-                  "transport-%s",
-                  PROTOCOL_PREFIX);
+  GNUNET_asprintf (&component_name, "transport-%s", PROTOCOL_PREFIX);
 
   plugin = GNUNET_malloc (sizeof (struct Plugin));
   plugin->stats = env->stats;
@@ -3317,8 +3315,8 @@ LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
   plugin->peers = NULL;
   plugin->bind4_address = NULL;
   plugin->bind6_address = NULL;
-  plugin->use_ipv6  = GNUNET_YES;
-  plugin->use_ipv4  = GNUNET_YES;
+  plugin->use_ipv6 = GNUNET_YES;
+  plugin->use_ipv4 = GNUNET_YES;
   plugin->use_localaddresses = GNUNET_NO;
 
   api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
@@ -3330,207 +3328,207 @@ LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
   api->address_to_string = &http_plugin_address_to_string;
 
   /* Hashing our identity to use it in URLs */
-  GNUNET_CRYPTO_hash_to_enc (&(plugin->env->my_identity->hashPubKey), 
-                             &plugin->my_ascii_hash_ident);
+  GNUNET_CRYPTO_hash_to_enc (&(plugin->env->my_identity->hashPubKey),
+                             &plugin->my_ascii_hash_ident);
 
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             component_name,
-                                             "MAX_CONNECTIONS",
-                                             &tneigh))
+                                             component_name,
+                                             "MAX_CONNECTIONS", &tneigh))
     tneigh = 128;
   plugin->max_connect_per_transport = tneigh;
 
 
   /* Use IPv6? */
-  if (GNUNET_CONFIGURATION_have_value (env->cfg,
-                                       component_name, "USE_IPv6"))
-    {
-      plugin->use_ipv6 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
-                                                               component_name,
-                                                               "USE_IPv6");
-    }
+  if (GNUNET_CONFIGURATION_have_value (env->cfg, component_name, "USE_IPv6"))
+  {
+    plugin->use_ipv6 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                             component_name,
+                                                             "USE_IPv6");
+  }
   /* Use IPv4? */
-  if (GNUNET_CONFIGURATION_have_value (env->cfg,
-                                       component_name, "USE_IPv4"))
-    {
-      plugin->use_ipv4 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
-                                                               component_name,"USE_IPv4");
-    }
+  if (GNUNET_CONFIGURATION_have_value (env->cfg, component_name, "USE_IPv4"))
+  {
+    plugin->use_ipv4 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                             component_name,
+                                                             "USE_IPv4");
+  }
   /* use local addresses? */
 
   if (GNUNET_CONFIGURATION_have_value (env->cfg,
-                                       component_name, "USE_LOCALADDR"))
-    {
-      plugin->use_localaddresses = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
-                                                               component_name,
-                                                               "USE_LOCALADDR");
-    }
+                                       component_name, "USE_LOCALADDR"))
+  {
+    plugin->use_localaddresses = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                                       component_name,
+                                                                       "USE_LOCALADDR");
+  }
   /* Reading port number from config file */
   if ((GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                              component_name,
-                                              "PORT",
-                                              &port)) ||
-      (port > 65535) )
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       component_name,
-                       _("Require valid port number for transport plugin `%s' in configuration!\n"),
-                       PROTOCOL_PREFIX);
-      GNUNET_free(component_name);
-      LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
-      return NULL;
-    }
+                                              component_name,
+                                              "PORT", &port)) || (port > 65535))
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     component_name,
+                     _
+                     ("Require valid port number for transport plugin `%s' in configuration!\n"),
+                     PROTOCOL_PREFIX);
+    GNUNET_free (component_name);
+    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
+    return NULL;
+  }
 
   /* Reading ipv4 addresse to bind to from config file */
-  if ( (plugin->use_ipv4==GNUNET_YES) && 
-       (GNUNET_CONFIGURATION_have_value (env->cfg,
-                                         component_name, "BINDTO4")))
-    {
-      GNUNET_break (GNUNET_OK ==
-                    GNUNET_CONFIGURATION_get_value_string (env->cfg,
-                                                           component_name,
-                                                           "BINDTO4",
-                                                           &plugin->bind_hostname));
-      plugin->bind4_address = GNUNET_malloc(sizeof(struct sockaddr_in));
-      plugin->bind4_address->sin_family = AF_INET;
-      plugin->bind4_address->sin_port = htons (port);
-      
-      if (plugin->bind_hostname!=NULL)
-        {
-          if (inet_pton(AF_INET,plugin->bind_hostname, &plugin->bind4_address->sin_addr)<=0)
-            {
-              GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                               component_name,
-                               _("Misconfigured address to bind to in configuration!\n"));
-              GNUNET_free(plugin->bind4_address);
-              GNUNET_free(plugin->bind_hostname);
-              plugin->bind_hostname = NULL;
-              plugin->bind4_address = NULL;
-            }
-        }
+  if ((plugin->use_ipv4 == GNUNET_YES) &&
+      (GNUNET_CONFIGURATION_have_value (env->cfg, component_name, "BINDTO4")))
+  {
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                                         component_name,
+                                                         "BINDTO4",
+                                                         &plugin->bind_hostname));
+    plugin->bind4_address = GNUNET_malloc (sizeof (struct sockaddr_in));
+    plugin->bind4_address->sin_family = AF_INET;
+    plugin->bind4_address->sin_port = htons (port);
+
+    if (plugin->bind_hostname != NULL)
+    {
+      if (inet_pton
+          (AF_INET, plugin->bind_hostname,
+           &plugin->bind4_address->sin_addr) <= 0)
+      {
+        GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                         component_name,
+                         _
+                         ("Misconfigured address to bind to in configuration!\n"));
+        GNUNET_free (plugin->bind4_address);
+        GNUNET_free (plugin->bind_hostname);
+        plugin->bind_hostname = NULL;
+        plugin->bind4_address = NULL;
+      }
     }
-  
+  }
+
   /* Reading ipv4 addresse to bind to from config file */
-  if ( (plugin->use_ipv6==GNUNET_YES) && 
-       (GNUNET_CONFIGURATION_have_value (env->cfg,
-                                         component_name, "BINDTO6")))
-    {
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (env->cfg,
-                                                              component_name,
-                                                              "BINDTO6",
-                                                              &plugin->bind_hostname))
-        {
-          plugin->bind6_address = GNUNET_malloc(sizeof(struct sockaddr_in6));
-          plugin->bind6_address->sin6_family = AF_INET6;
-          plugin->bind6_address->sin6_port = htons (port);
-          if (plugin->bind_hostname!=NULL)
-            {
-              if (inet_pton(AF_INET6,plugin->bind_hostname, &plugin->bind6_address->sin6_addr)<=0)
-                {
-                  GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                                   component_name,
-                                   _("Misconfigured address to bind to in configuration!\n"));
-                  GNUNET_free(plugin->bind6_address);
-                  GNUNET_free(plugin->bind_hostname);
-                  plugin->bind_hostname = NULL;
-                  plugin->bind6_address = NULL;
-                }
-            }
-        }
+  if ((plugin->use_ipv6 == GNUNET_YES) &&
+      (GNUNET_CONFIGURATION_have_value (env->cfg, component_name, "BINDTO6")))
+  {
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                                            component_name,
+                                                            "BINDTO6",
+                                                            &plugin->bind_hostname))
+    {
+      plugin->bind6_address = GNUNET_malloc (sizeof (struct sockaddr_in6));
+      plugin->bind6_address->sin6_family = AF_INET6;
+      plugin->bind6_address->sin6_port = htons (port);
+      if (plugin->bind_hostname != NULL)
+      {
+        if (inet_pton
+            (AF_INET6, plugin->bind_hostname,
+             &plugin->bind6_address->sin6_addr) <= 0)
+        {
+          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                           component_name,
+                           _
+                           ("Misconfigured address to bind to in configuration!\n"));
+          GNUNET_free (plugin->bind6_address);
+          GNUNET_free (plugin->bind_hostname);
+          plugin->bind_hostname = NULL;
+          plugin->bind6_address = NULL;
+        }
+      }
     }
-  
+  }
+
 #if BUILD_HTTPS
   /* Reading HTTPS crypto related configuration */
-  /* Get crypto init string from config */  
-  if ( (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_string (env->cfg,
-                                               "transport-https",
-                                               "CRYPTO_INIT",
-                                               &plugin->crypto_init)) ||
-       (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_filename (env->cfg,
-                                                 "transport-https",
-                                                 "KEY_FILE",
-                                                 &key_file)) ||
-       (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_filename (env->cfg,
-                                                 "transport-https",
-                                                 "CERT_FILE",
-                                                 &cert_file)) )
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "https",
-                       _("Required configuration options missing in section `%s'\n"),
-                       "transport-https");
-      GNUNET_free (component_name);
-      GNUNET_free_non_null (key_file);
-      GNUNET_free_non_null (cert_file);
-      LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
-      return NULL;   
-    }
- 
+  /* Get crypto init string from config */
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                              "transport-https",
+                                              "CRYPTO_INIT",
+                                              &plugin->crypto_init)) ||
+      (GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_filename (env->cfg,
+                                                "transport-https",
+                                                "KEY_FILE",
+                                                &key_file)) ||
+      (GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_filename (env->cfg,
+                                                "transport-https",
+                                                "CERT_FILE", &cert_file)))
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "https",
+                     _
+                     ("Required configuration options missing in section `%s'\n"),
+                     "transport-https");
+    GNUNET_free (component_name);
+    GNUNET_free_non_null (key_file);
+    GNUNET_free_non_null (cert_file);
+    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
+    return NULL;
+  }
+
   /* read key & certificates from file */
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Loading TLS certificate `%s' `%s'\n", 
-              key_file, cert_file);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Loading TLS certificate `%s' `%s'\n", key_file, cert_file);
 
   plugin->key = load_certificate (key_file);
   plugin->cert = load_certificate (cert_file);
 
-  if ( (plugin->key==NULL) || (plugin->cert==NULL) )
-    {
-      struct GNUNET_OS_Process *certcreation;
+  if ((plugin->key == NULL) || (plugin->cert == NULL))
+  {
+    struct GNUNET_OS_Process *certcreation;
 
-      GNUNET_free_non_null (plugin->key);
-      plugin->key = NULL;
-      GNUNET_free_non_null (plugin->cert);
-      plugin->cert = NULL;
+    GNUNET_free_non_null (plugin->key);
+    plugin->key = NULL;
+    GNUNET_free_non_null (plugin->cert);
+    plugin->cert = NULL;
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No usable TLS certificate found, creating certificate\n");
-#endif
-      errno = 0;
-      certcreation = GNUNET_OS_start_process (NULL, NULL,
-                                              "gnunet-transport-certificate-creation", 
-                                              "gnunet-transport-certificate-creation", 
-                                              key_file, cert_file,
-                                              NULL);
-      if (certcreation == NULL) 
-        {
-          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                           "https",
-                           _("Could not create a new TLS certificate, program `gnunet-transport-certificate-creation' could not be started!\n"));
-          GNUNET_free (key_file);
-          GNUNET_free (cert_file);
-          GNUNET_free (component_name);
-          LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
-          return NULL;
-        }
-      GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (certcreation));
-      GNUNET_OS_process_close (certcreation);
-      plugin->key = load_certificate (key_file);
-      plugin->cert = load_certificate (cert_file);
-    }
-  if ( (plugin->key==NULL) || (plugin->cert==NULL) )
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No usable TLS certificate found, creating certificate\n");
+#endif
+    errno = 0;
+    certcreation = GNUNET_OS_start_process (NULL, NULL,
+                                            "gnunet-transport-certificate-creation",
+                                            "gnunet-transport-certificate-creation",
+                                            key_file, cert_file, NULL);
+    if (certcreation == NULL)
     {
       GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "https",
-                       _("No usable TLS certificate found and creating one failed!\n"),
-                       "transport-https");
+                       "https",
+                       _
+                       ("Could not create a new TLS certificate, program `gnunet-transport-certificate-creation' could not be started!\n"));
       GNUNET_free (key_file);
       GNUNET_free (cert_file);
-      GNUNET_free (component_name);       
+      GNUNET_free (component_name);
       LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
       return NULL;
-    }    
+    }
+    GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (certcreation));
+    GNUNET_OS_process_close (certcreation);
+    plugin->key = load_certificate (key_file);
+    plugin->cert = load_certificate (cert_file);
+  }
+  if ((plugin->key == NULL) || (plugin->cert == NULL))
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "https",
+                     _
+                     ("No usable TLS certificate found and creating one failed!\n"),
+                     "transport-https");
+    GNUNET_free (key_file);
+    GNUNET_free (cert_file);
+    GNUNET_free (component_name);
+    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
+    return NULL;
+  }
   GNUNET_free (key_file);
   GNUNET_free (cert_file);
 #if DEBUG_HTTP
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "TLS certificate loaded\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TLS certificate loaded\n");
 #endif
 #endif
 
@@ -3538,171 +3536,199 @@ LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
   plugin->port_inbound = port;
   gn_timeout = GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT;
   unsigned int timeout = (gn_timeout.rel_value) / 1000;
-  if ( (plugin->http_server_daemon_v6 == NULL) && 
-       (plugin->use_ipv6 == GNUNET_YES) && 
-       (port != 0) )
-    {
-      struct sockaddr * tmp = (struct sockaddr *) plugin->bind6_address;
-      plugin->http_server_daemon_v6 = MHD_start_daemon (
+
+  if ((plugin->http_server_daemon_v6 == NULL) &&
+      (plugin->use_ipv6 == GNUNET_YES) && (port != 0))
+  {
+    struct sockaddr *tmp = (struct sockaddr *) plugin->bind6_address;
+
+    plugin->http_server_daemon_v6 = MHD_start_daemon (
 #if DEBUG_MHD
-                                                        MHD_USE_DEBUG |
+                                                       MHD_USE_DEBUG |
 #endif
 #if BUILD_HTTPS
-                                                        MHD_USE_SSL |
-#endif
-                                                        MHD_USE_IPv6,
-                                                        port,
-                                                        &mhd_accept_cb, plugin,
-                                                        &mhd_access_cb, plugin,
-                                                        MHD_OPTION_SOCK_ADDR, tmp,
-                                                        MHD_OPTION_CONNECTION_LIMIT, (unsigned int) plugin->max_connect_per_transport,
+                                                       MHD_USE_SSL |
+#endif
+                                                       MHD_USE_IPv6,
+                                                       port,
+                                                       &mhd_accept_cb, plugin,
+                                                       &mhd_access_cb, plugin,
+                                                       MHD_OPTION_SOCK_ADDR,
+                                                       tmp,
+                                                       MHD_OPTION_CONNECTION_LIMIT,
+                                                       (unsigned int)
+                                                       plugin->max_connect_per_transport,
 #if BUILD_HTTPS
-                                                        MHD_OPTION_HTTPS_PRIORITIES,  plugin->crypto_init,
-                                                        MHD_OPTION_HTTPS_MEM_KEY, plugin->key,
-                                                        MHD_OPTION_HTTPS_MEM_CERT, plugin->cert,
-#endif
-                                                        MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) timeout,
-                                                        MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (2 * GNUNET_SERVER_MAX_MESSAGE_SIZE),
-                                                        MHD_OPTION_NOTIFY_COMPLETED, &mhd_termination_cb, plugin,
-                                                        MHD_OPTION_EXTERNAL_LOGGER, mhd_logger, plugin->mhd_log,
-                                                        MHD_OPTION_END);
-    }
-  if ( (plugin->http_server_daemon_v4 == NULL) && 
-       (plugin->use_ipv4 == GNUNET_YES) && 
-       (port != 0) )
-    {
-      plugin->http_server_daemon_v4 = MHD_start_daemon (
+                                                       MHD_OPTION_HTTPS_PRIORITIES,
+                                                       plugin->crypto_init,
+                                                       MHD_OPTION_HTTPS_MEM_KEY,
+                                                       plugin->key,
+                                                       MHD_OPTION_HTTPS_MEM_CERT,
+                                                       plugin->cert,
+#endif
+                                                       MHD_OPTION_CONNECTION_TIMEOUT,
+                                                       (unsigned int) timeout,
+                                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                                                       (size_t) (2 *
+                                                                 GNUNET_SERVER_MAX_MESSAGE_SIZE),
+                                                       MHD_OPTION_NOTIFY_COMPLETED,
+                                                       &mhd_termination_cb,
+                                                       plugin,
+                                                       MHD_OPTION_EXTERNAL_LOGGER,
+                                                       mhd_logger,
+                                                       plugin->mhd_log,
+                                                       MHD_OPTION_END);
+  }
+  if ((plugin->http_server_daemon_v4 == NULL) &&
+      (plugin->use_ipv4 == GNUNET_YES) && (port != 0))
+  {
+    plugin->http_server_daemon_v4 = MHD_start_daemon (
 #if DEBUG_MHD
-                                                        MHD_USE_DEBUG |
+                                                       MHD_USE_DEBUG |
 #endif
 #if BUILD_HTTPS
-                                                        MHD_USE_SSL |
-#endif
-                                                        MHD_NO_FLAG,
-                                                        port,
-                                                        &mhd_accept_cb, plugin ,
-                                                        &mhd_access_cb, plugin,
-                                                        MHD_OPTION_SOCK_ADDR, (struct sockaddr_in *) plugin->bind4_address,
-                                                        MHD_OPTION_CONNECTION_LIMIT, (unsigned int) plugin->max_connect_per_transport,
+                                                       MHD_USE_SSL |
+#endif
+                                                       MHD_NO_FLAG,
+                                                       port,
+                                                       &mhd_accept_cb, plugin,
+                                                       &mhd_access_cb, plugin,
+                                                       MHD_OPTION_SOCK_ADDR,
+                                                       (struct sockaddr_in *)
+                                                       plugin->bind4_address,
+                                                       MHD_OPTION_CONNECTION_LIMIT,
+                                                       (unsigned int)
+                                                       plugin->max_connect_per_transport,
 #if BUILD_HTTPS
-                                                        MHD_OPTION_HTTPS_PRIORITIES,  plugin->crypto_init,
-
-                                                        MHD_OPTION_HTTPS_MEM_KEY, plugin->key,
-                                                        MHD_OPTION_HTTPS_MEM_CERT, plugin->cert,
-#endif
-                                                        MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) timeout,
-                                                        MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (2 * GNUNET_SERVER_MAX_MESSAGE_SIZE),
-                                                        MHD_OPTION_NOTIFY_COMPLETED, &mhd_termination_cb, plugin,
-                                                        MHD_OPTION_EXTERNAL_LOGGER, mhd_logger, plugin->mhd_log,
-                                                        MHD_OPTION_END);
-    }
+                                                       MHD_OPTION_HTTPS_PRIORITIES,
+                                                       plugin->crypto_init,
+                                                       MHD_OPTION_HTTPS_MEM_KEY,
+                                                       plugin->key,
+                                                       MHD_OPTION_HTTPS_MEM_CERT,
+                                                       plugin->cert,
+#endif
+                                                       MHD_OPTION_CONNECTION_TIMEOUT,
+                                                       (unsigned int) timeout,
+                                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                                                       (size_t) (2 *
+                                                                 GNUNET_SERVER_MAX_MESSAGE_SIZE),
+                                                       MHD_OPTION_NOTIFY_COMPLETED,
+                                                       &mhd_termination_cb,
+                                                       plugin,
+                                                       MHD_OPTION_EXTERNAL_LOGGER,
+                                                       mhd_logger,
+                                                       plugin->mhd_log,
+                                                       MHD_OPTION_END);
+  }
   if (plugin->http_server_daemon_v4 != NULL)
-    plugin->http_server_task_v4 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v4);
+    plugin->http_server_task_v4 =
+        http_server_daemon_prepare (plugin, plugin->http_server_daemon_v4);
   if (plugin->http_server_daemon_v6 != NULL)
-    plugin->http_server_task_v6 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v6);
-  
-  
+    plugin->http_server_task_v6 =
+        http_server_daemon_prepare (plugin, plugin->http_server_daemon_v6);
+
+
   if (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
-    {
+  {
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Starting MHD with IPv4 bound to %s with port %u\n",
-                  (plugin->bind_hostname!=NULL) ? plugin->bind_hostname : "every address",port);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting MHD with IPv4 bound to %s with port %u\n",
+                (plugin->bind_hostname !=
+                 NULL) ? plugin->bind_hostname : "every address", port);
 #endif
-    }
-  else if ( (plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK) && 
-            (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK) )
-    {
+  }
+  else if ((plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK) &&
+           (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK))
+  {
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Starting MHD with IPv6 bound to %s with port %u\n",
-                  (plugin->bind_hostname!=NULL) ? plugin->bind_hostname : "every address", port);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting MHD with IPv6 bound to %s with port %u\n",
+                (plugin->bind_hostname !=
+                 NULL) ? plugin->bind_hostname : "every address", port);
 #endif
-    }
-  else if ( (plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK) && 
-            (plugin->http_server_task_v4 == GNUNET_SCHEDULER_NO_TASK) )
-    {
+  }
+  else if ((plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK) &&
+           (plugin->http_server_task_v4 == GNUNET_SCHEDULER_NO_TASK))
+  {
 #if DEBUG_HTTP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Starting MHD with IPv4 and IPv6 bound to %s with port %u\n",
-                  (plugin->bind_hostname!=NULL) ? plugin->bind_hostname : "every address", 
-                  port);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting MHD with IPv4 and IPv6 bound to %s with port %u\n",
+                (plugin->bind_hostname !=
+                 NULL) ? plugin->bind_hostname : "every address", port);
 #endif
-    }
+  }
   else
-    {
-      char * tmp = NULL;
-      if ((plugin->use_ipv6 == GNUNET_YES) && (plugin->use_ipv4 == GNUNET_YES))
-        GNUNET_asprintf(&tmp,"with IPv4 and IPv6 enabled");
-      if ((plugin->use_ipv6 == GNUNET_NO) && (plugin->use_ipv4 == GNUNET_YES))
-        GNUNET_asprintf(&tmp,"with IPv4 enabled");
-      if ((plugin->use_ipv6 == GNUNET_YES) && (plugin->use_ipv4 == GNUNET_NO))
-        GNUNET_asprintf(&tmp,"with IPv6 enabled");
-      if ((plugin->use_ipv6 == GNUNET_NO) && (plugin->use_ipv4 == GNUNET_NO))
-        GNUNET_asprintf(&tmp,"with NO IP PROTOCOL enabled");
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("HTTP Server with %s could not be started on port %u! %s plugin failed!\n"),
-                  tmp, port, PROTOCOL_PREFIX);
-      GNUNET_free (tmp);
-      GNUNET_free (component_name);
-      LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
-      return NULL;
-    }
-  
+  {
+    char *tmp = NULL;
+
+    if ((plugin->use_ipv6 == GNUNET_YES) && (plugin->use_ipv4 == GNUNET_YES))
+      GNUNET_asprintf (&tmp, "with IPv4 and IPv6 enabled");
+    if ((plugin->use_ipv6 == GNUNET_NO) && (plugin->use_ipv4 == GNUNET_YES))
+      GNUNET_asprintf (&tmp, "with IPv4 enabled");
+    if ((plugin->use_ipv6 == GNUNET_YES) && (plugin->use_ipv4 == GNUNET_NO))
+      GNUNET_asprintf (&tmp, "with IPv6 enabled");
+    if ((plugin->use_ipv6 == GNUNET_NO) && (plugin->use_ipv4 == GNUNET_NO))
+      GNUNET_asprintf (&tmp, "with NO IP PROTOCOL enabled");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("HTTP Server with %s could not be started on port %u! %s plugin failed!\n"),
+                tmp, port, PROTOCOL_PREFIX);
+    GNUNET_free (tmp);
+    GNUNET_free (component_name);
+    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
+    return NULL;
+  }
+
   /* Initializing cURL */
-  curl_global_init(CURL_GLOBAL_ALL);
-  plugin->multi_handle = curl_multi_init();
-  
-  if ( NULL == plugin->multi_handle )
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       component_name,
-                       _("Could not initialize curl multi handle, failed to start %s plugin!\n"),
-                       PROTOCOL_PREFIX);
-      GNUNET_free(component_name);
-      LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
-      return NULL;
-    }
-  
+  curl_global_init (CURL_GLOBAL_ALL);
+  plugin->multi_handle = curl_multi_init ();
+
+  if (NULL == plugin->multi_handle)
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     component_name,
+                     _
+                     ("Could not initialize curl multi handle, failed to start %s plugin!\n"),
+                     PROTOCOL_PREFIX);
+    GNUNET_free (component_name);
+    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
+    return NULL;
+  }
+
   ret = GNUNET_SERVICE_get_server_addresses (component_name,
-                          env->cfg,
-                          &addrs,
-                          &addrlens);
+                                             env->cfg, &addrs, &addrlens);
 
   if (ret != GNUNET_SYSERR)
   {
     plugin->nat = GNUNET_NAT_register (env->cfg,
-                                         GNUNET_YES,
-                                         port,
-                                         (unsigned int) ret,
-                                         (const struct sockaddr **) addrs,
-                                         addrlens,
-                                         &tcp_nat_port_map_callback,
-                                         &try_connection_reversal,
-                                         plugin);
-      while (ret > 0)
-      {
-        ret--;
-        GNUNET_assert (addrs[ret] != NULL);
-        GNUNET_free (addrs[ret]);
-      }
-      GNUNET_free_non_null (addrs);
-      GNUNET_free_non_null (addrlens);
+                                       GNUNET_YES,
+                                       port,
+                                       (unsigned int) ret,
+                                       (const struct sockaddr **) addrs,
+                                       addrlens,
+                                       &tcp_nat_port_map_callback,
+                                       &try_connection_reversal, plugin);
+    while (ret > 0)
+    {
+      ret--;
+      GNUNET_assert (addrs[ret] != NULL);
+      GNUNET_free (addrs[ret]);
+    }
+    GNUNET_free_non_null (addrs);
+    GNUNET_free_non_null (addrlens);
   }
   else
   {
     plugin->nat = GNUNET_NAT_register (env->cfg,
-         GNUNET_YES,
-         0,
-         0, NULL, NULL,
-         NULL,
-         &try_connection_reversal,
-         plugin);
+                                       GNUNET_YES,
+                                       0,
+                                       0, NULL, NULL,
+                                       NULL, &try_connection_reversal, plugin);
   }
 
   plugin->peers = GNUNET_CONTAINER_multihashmap_create (10);
-  
-  GNUNET_free(component_name);
+
+  GNUNET_free (component_name);
   //GNUNET_SCHEDULER_add_now(address_notification, plugin);
   return api;
 }
diff --git a/src/transport/plugin_transport_smtp.c b/src/transport/plugin_transport_smtp.c
index 9c0ac5ea5..074bc16fc 100644
--- a/src/transport/plugin_transport_smtp.c
+++ b/src/transport/plugin_transport_smtp.c
@@ -146,7 +146,7 @@ static GNUNET_CronTime last_transmission;
 
 #define FILLCHAR '='
 static char *cvt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-  "abcdefghijklmnopqrstuvwxyz" "0123456789+/";
+    "abcdefghijklmnopqrstuvwxyz" "0123456789+/";
 
 /**
  * Encode into Base64.
@@ -179,41 +179,41 @@ base64_encode (const char *data, unsigned int len, char **output)
   opt[1] = '\n';
   ret += 2;
   for (i = 0; i < len; ++i)
+  {
+    c = (data[i] >> 2) & 0x3f;
+    opt[ret++] = cvt[(int) c];
+    CHECKLINE;
+    c = (data[i] << 4) & 0x3f;
+    if (++i < len)
+      c |= (data[i] >> 4) & 0x0f;
+    opt[ret++] = cvt[(int) c];
+    CHECKLINE;
+    if (i < len)
     {
-      c = (data[i] >> 2) & 0x3f;
+      c = (data[i] << 2) & 0x3f;
+      if (++i < len)
+        c |= (data[i] >> 6) & 0x03;
       opt[ret++] = cvt[(int) c];
       CHECKLINE;
-      c = (data[i] << 4) & 0x3f;
-      if (++i < len)
-        c |= (data[i] >> 4) & 0x0f;
+    }
+    else
+    {
+      ++i;
+      opt[ret++] = FILLCHAR;
+      CHECKLINE;
+    }
+    if (i < len)
+    {
+      c = data[i] & 0x3f;
       opt[ret++] = cvt[(int) c];
       CHECKLINE;
-      if (i < len)
-        {
-          c = (data[i] << 2) & 0x3f;
-          if (++i < len)
-            c |= (data[i] >> 6) & 0x03;
-          opt[ret++] = cvt[(int) c];
-          CHECKLINE;
-        }
-      else
-        {
-          ++i;
-          opt[ret++] = FILLCHAR;
-          CHECKLINE;
-        }
-      if (i < len)
-        {
-          c = data[i] & 0x3f;
-          opt[ret++] = cvt[(int) c];
-          CHECKLINE;
-        }
-      else
-        {
-          opt[ret++] = FILLCHAR;
-          CHECKLINE;
-        }
     }
+    else
+    {
+      opt[ret++] = FILLCHAR;
+      CHECKLINE;
+    }
+  }
   opt[ret++] = FILLCHAR;
   return ret;
 }
@@ -252,38 +252,38 @@ base64_decode (const char *data, unsigned int len, char **output)
                  "base64_decode decoding len=%d\n", len);
 #endif
   for (i = 0; i < len; ++i)
+  {
+    CHECK_CRLF;
+    if (data[i] == FILLCHAR)
+      break;
+    c = (char) cvtfind (data[i]);
+    ++i;
+    CHECK_CRLF;
+    c1 = (char) cvtfind (data[i]);
+    c = (c << 2) | ((c1 >> 4) & 0x3);
+    (*output)[ret++] = c;
+    if (++i < len)
     {
       CHECK_CRLF;
-      if (data[i] == FILLCHAR)
+      c = data[i];
+      if (FILLCHAR == c)
         break;
-      c = (char) cvtfind (data[i]);
-      ++i;
+      c = (char) cvtfind (c);
+      c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
+      (*output)[ret++] = c1;
+    }
+    if (++i < len)
+    {
       CHECK_CRLF;
-      c1 = (char) cvtfind (data[i]);
-      c = (c << 2) | ((c1 >> 4) & 0x3);
+      c1 = data[i];
+      if (FILLCHAR == c1)
+        break;
+
+      c1 = (char) cvtfind (c1);
+      c = ((c << 6) & 0xc0) | c1;
       (*output)[ret++] = c;
-      if (++i < len)
-        {
-          CHECK_CRLF;
-          c = data[i];
-          if (FILLCHAR == c)
-            break;
-          c = (char) cvtfind (c);
-          c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
-          (*output)[ret++] = c1;
-        }
-      if (++i < len)
-        {
-          CHECK_CRLF;
-          c1 = data[i];
-          if (FILLCHAR == c1)
-            break;
-
-          c1 = (char) cvtfind (c1);
-          c = ((c << 6) & 0xc0) | c1;
-          (*output)[ret++] = c;
-        }
     }
+  }
 END:
   return ret;
 }
@@ -323,83 +323,83 @@ listenAndDistribute (void *unused)
 
 
   while (smtp_shutdown == GNUNET_NO)
+  {
+    fd = OPEN (pipename, O_RDONLY | O_ASYNC);
+    if (fd == -1)
     {
-      fd = OPEN (pipename, O_RDONLY | O_ASYNC);
-      if (fd == -1)
-        {
-          if (smtp_shutdown == GNUNET_NO)
-            GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);
-          continue;
-        }
-      fdes = fdopen (fd, "r");
-      while (smtp_shutdown == GNUNET_NO)
-        {
-          /* skip until end of header */
-          do
-            {
-              READLINE (line, linesize);
-            }
-          while ((line[0] != '\r') && (line[0] != '\n'));       /* expect newline */
-          READLINE (line, linesize);    /* read base64 encoded message; decode, process */
-          pos = 0;
-          while (1)
-            {
-              pos = strlen (line) - 1;  /* ignore new line */
-              READLINE (&line[pos], linesize - pos);    /* read base64 encoded message; decode, process */
-              if ((line[pos] == '\r') || (line[pos] == '\n'))
-                break;          /* empty line => end of message! */
-            }
-          size = base64_decode (line, pos, &out);
-          if (size < sizeof (SMTPMessage))
-            {
-              GNUNET_GE_BREAK (ectx, 0);
-              GNUNET_free (out);
-              goto END;
-            }
-
-          mp = (SMTPMessage *) & out[size - sizeof (SMTPMessage)];
-          if (ntohs (mp->header.size) != size)
-            {
-              GNUNET_GE_LOG (ectx,
-                             GNUNET_GE_WARNING | GNUNET_GE_BULK |
-                             GNUNET_GE_USER,
-                             _
-                             ("Received malformed message via %s. Ignored.\n"),
-                             "SMTP");
-#if DEBUG_SMTP
-              GNUNET_GE_LOG (ectx,
-                             GNUNET_GE_DEBUG | GNUNET_GE_REQUEST |
-                             GNUNET_GE_USER,
-                             "Size returned by base64=%d, in the msg=%d.\n",
-                             size, ntohl (mp->size));
-#endif
-              GNUNET_free (out);
-              goto END;
-            }
-          if (stats != NULL)
-            stats->change (stat_bytesReceived, size);
-          coreMP = GNUNET_malloc (sizeof (GNUNET_TransportPacket));
-          coreMP->msg = out;
-          coreMP->size = size - sizeof (SMTPMessage);
-          coreMP->tsession = NULL;
-          coreMP->sender = mp->sender;
+      if (smtp_shutdown == GNUNET_NO)
+        GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);
+      continue;
+    }
+    fdes = fdopen (fd, "r");
+    while (smtp_shutdown == GNUNET_NO)
+    {
+      /* skip until end of header */
+      do
+      {
+        READLINE (line, linesize);
+      }
+      while ((line[0] != '\r') && (line[0] != '\n'));   /* expect newline */
+      READLINE (line, linesize);        /* read base64 encoded message; decode, process */
+      pos = 0;
+      while (1)
+      {
+        pos = strlen (line) - 1;        /* ignore new line */
+        READLINE (&line[pos], linesize - pos);  /* read base64 encoded message; decode, process */
+        if ((line[pos] == '\r') || (line[pos] == '\n'))
+          break;                /* empty line => end of message! */
+      }
+      size = base64_decode (line, pos, &out);
+      if (size < sizeof (SMTPMessage))
+      {
+        GNUNET_GE_BREAK (ectx, 0);
+        GNUNET_free (out);
+        goto END;
+      }
+
+      mp = (SMTPMessage *) &out[size - sizeof (SMTPMessage)];
+      if (ntohs (mp->header.size) != size)
+      {
+        GNUNET_GE_LOG (ectx,
+                       GNUNET_GE_WARNING | GNUNET_GE_BULK |
+                       GNUNET_GE_USER,
+                       _
+                       ("Received malformed message via %s. Ignored.\n"),
+                       "SMTP");
 #if DEBUG_SMTP
-          GNUNET_GE_LOG (ectx,
-                         GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
-                         "SMTP message passed to the core.\n");
+        GNUNET_GE_LOG (ectx,
+                       GNUNET_GE_DEBUG | GNUNET_GE_REQUEST |
+                       GNUNET_GE_USER,
+                       "Size returned by base64=%d, in the msg=%d.\n",
+                       size, ntohl (mp->size));
 #endif
-
-          coreAPI->receive (coreMP);
-        }
-    END:
+        GNUNET_free (out);
+        goto END;
+      }
+      if (stats != NULL)
+        stats->change (stat_bytesReceived, size);
+      coreMP = GNUNET_malloc (sizeof (GNUNET_TransportPacket));
+      coreMP->msg = out;
+      coreMP->size = size - sizeof (SMTPMessage);
+      coreMP->tsession = NULL;
+      coreMP->sender = mp->sender;
 #if DEBUG_SMTP
       GNUNET_GE_LOG (ectx,
                      GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
-                     "SMTP message processed.\n");
+                     "SMTP message passed to the core.\n");
 #endif
-      if (fdes != NULL)
-        fclose (fdes);
+
+      coreAPI->receive (coreMP);
     }
+END:
+#if DEBUG_SMTP
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
+                   "SMTP message processed.\n");
+#endif
+    if (fdes != NULL)
+      fclose (fdes);
+  }
   GNUNET_free (line);
   return NULL;
 }
@@ -425,10 +425,10 @@ api_verify_hello (const GNUNET_MessageHello * hello)
        sizeof (GNUNET_MessageHello) + ntohs (hello->senderAddressSize)) ||
       (maddr->senderAddress[ntohs (hello->senderAddressSize) - 1 -
                             FILTER_STRING_SIZE] != '\0'))
-    {
-      GNUNET_GE_BREAK (ectx, 0);
-      return GNUNET_SYSERR;     /* obviously invalid */
-    }
+  {
+    GNUNET_GE_BREAK (ectx, 0);
+    return GNUNET_SYSERR;       /* obviously invalid */
+  }
   if (NULL == strstr (maddr->filter, ": "))
     return GNUNET_SYSERR;
   return GNUNET_OK;
@@ -453,27 +453,26 @@ api_create_hello ()
                                             "SMTP", "FILTER",
                                             "X-mailer: GNUnet", &filter);
   if (NULL == strstr (filter, ": "))
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
-                     _("SMTP filter string to invalid, lacks ': '\n"));
-      GNUNET_free (filter);
-      return NULL;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
+                   _("SMTP filter string to invalid, lacks ': '\n"));
+    GNUNET_free (filter);
+    return NULL;
+  }
 
   if (strlen (filter) > FILTER_STRING_SIZE)
-    {
-      filter[FILTER_STRING_SIZE] = '\0';
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
-                     _("SMTP filter string to long, capped to `%s'\n"),
-                     filter);
-    }
+  {
+    filter[FILTER_STRING_SIZE] = '\0';
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
+                   _("SMTP filter string to long, capped to `%s'\n"), filter);
+  }
   i = (strlen (email) + 8) & (~7);      /* make multiple of 8 */
   msg =
-    GNUNET_malloc (sizeof (GNUNET_MessageHello) + sizeof (EmailAddress) + i);
+      GNUNET_malloc (sizeof (GNUNET_MessageHello) + sizeof (EmailAddress) + i);
   memset (msg, 0, sizeof (GNUNET_MessageHello) + sizeof (EmailAddress) + i);
-  haddr = (EmailAddress *) & msg[1];
+  haddr = (EmailAddress *) &msg[1];
   memset (&haddr->filter[0], 0, FILTER_STRING_SIZE);
   strcpy (&haddr->filter[0], filter);
   memcpy (&haddr->senderAddress[0], email, strlen (email) + 1);
@@ -501,10 +500,10 @@ get_message (void **buf, int *len, void *cls)
 
   *buf = NULL;
   if (len == NULL)
-    {
-      gmc->pos = 0;
-      return NULL;
-    }
+  {
+    gmc->pos = 0;
+    return NULL;
+  }
   if (gmc->pos == gmc->esize)
     return NULL;                /* done */
   *len = gmc->esize;
@@ -535,6 +534,7 @@ api_send (GNUNET_TSession * tsession,
   smtp_session_t session;
   smtp_message_t message;
   smtp_recipient_t recipient;
+
 #define EBUF_LEN 128
   char ebuf[EBUF_LEN];
   GNUNET_CronTime now;
@@ -542,10 +542,10 @@ api_send (GNUNET_TSession * tsession,
   if (smtp_shutdown == GNUNET_YES)
     return GNUNET_SYSERR;
   if ((size == 0) || (size > smtpAPI.mtu))
-    {
-      GNUNET_GE_BREAK (ectx, 0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_BREAK (ectx, 0);
+    return GNUNET_SYSERR;
+  }
   now = GNUNET_get_time ();
   if ((important != GNUNET_YES) &&
       ((now - last_transmission) * rate_limit) < GNUNET_CRON_HOURS)
@@ -558,42 +558,42 @@ api_send (GNUNET_TSession * tsession,
   GNUNET_mutex_lock (lock);
   session = smtp_create_session ();
   if (session == NULL)
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_IMMEDIATE,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_create_session",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-      GNUNET_mutex_unlock (lock);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_IMMEDIATE,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_create_session",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+    GNUNET_mutex_unlock (lock);
+    return GNUNET_SYSERR;
+  }
   if (0 == smtp_set_server (session, smtp_server_name))
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_IMMEDIATE,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_set_server",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-      smtp_destroy_session (session);
-      GNUNET_mutex_unlock (lock);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_IMMEDIATE,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_set_server",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+    smtp_destroy_session (session);
+    GNUNET_mutex_unlock (lock);
+    return GNUNET_SYSERR;
+  }
   haddr = (const EmailAddress *) &hello[1];
   message = smtp_add_message (session);
   if (message == NULL)
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_BULK,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_add_message",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-      smtp_destroy_session (session);
-      GNUNET_mutex_unlock (lock);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_BULK,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_add_message",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+    smtp_destroy_session (session);
+    GNUNET_mutex_unlock (lock);
+    return GNUNET_SYSERR;
+  }
   smtp_set_header (message, "To", NULL, haddr->senderAddress);
   smtp_set_header (message, "From", NULL, email);
 
@@ -603,84 +603,82 @@ api_send (GNUNET_TSession * tsession,
   fvalue[0] = '\0';
   fvalue += 2;
   if (0 == smtp_set_header (message, filter, fvalue))
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_BULK,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_set_header",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-      smtp_destroy_session (session);
-      GNUNET_mutex_unlock (lock);
-      GNUNET_free (filter);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_BULK,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_set_header",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+    smtp_destroy_session (session);
+    GNUNET_mutex_unlock (lock);
+    GNUNET_free (filter);
+    return GNUNET_SYSERR;
+  }
   GNUNET_free (filter);
   m = GNUNET_malloc (size + sizeof (SMTPMessage));
   memcpy (m, msg, size);
-  mp = (SMTPMessage *) & m[size];
+  mp = (SMTPMessage *) &m[size];
   mp->header.size = htons (size + sizeof (SMTPMessage));
   mp->header.type = htons (0);
   mp->sender = *coreAPI->my_identity;
   gm_cls.ebody = NULL;
   gm_cls.pos = 0;
-  gm_cls.esize =
-    base64_encode (m, size + sizeof (SMTPMessage), &gm_cls.ebody);
+  gm_cls.esize = base64_encode (m, size + sizeof (SMTPMessage), &gm_cls.ebody);
   GNUNET_free (m);
   if (0 == smtp_size_set_estimate (message, gm_cls.esize))
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_BULK,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_size_set_estimate",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_BULK,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_size_set_estimate",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+  }
   if (0 == smtp_set_messagecb (message, &get_message, &gm_cls))
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_BULK,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_set_messagecb",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-      smtp_destroy_session (session);
-      GNUNET_mutex_unlock (lock);
-      GNUNET_free (gm_cls.ebody);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_BULK,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_set_messagecb",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+    smtp_destroy_session (session);
+    GNUNET_mutex_unlock (lock);
+    GNUNET_free (gm_cls.ebody);
+    return GNUNET_SYSERR;
+  }
   recipient = smtp_add_recipient (message, haddr->senderAddress);
   if (recipient == NULL)
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_BULK,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_add_recipient",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-      smtp_destroy_session (session);
-      GNUNET_mutex_unlock (lock);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_BULK,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_add_recipient",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+    smtp_destroy_session (session);
+    GNUNET_mutex_unlock (lock);
+    return GNUNET_SYSERR;
+  }
   if (0 == smtp_start_session (session))
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
-                     GNUNET_GE_BULK,
-                     _("SMTP: `%s' failed: %s.\n"),
-                     "smtp_start_session",
-                     smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
-      smtp_destroy_session (session);
-      GNUNET_mutex_unlock (lock);
-      GNUNET_free (gm_cls.ebody);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER |
+                   GNUNET_GE_BULK,
+                   _("SMTP: `%s' failed: %s.\n"),
+                   "smtp_start_session",
+                   smtp_strerror (smtp_errno (), ebuf, EBUF_LEN));
+    smtp_destroy_session (session);
+    GNUNET_mutex_unlock (lock);
+    GNUNET_free (gm_cls.ebody);
+    return GNUNET_SYSERR;
+  }
   if (stats != NULL)
     stats->change (stat_bytesSent, size);
   if (coreAPI->load_monitor != NULL)
     GNUNET_network_monitor_notify_transmission (coreAPI->load_monitor,
-                                                GNUNET_ND_UPLOAD,
-                                                gm_cls.esize);
+                                                GNUNET_ND_UPLOAD, gm_cls.esize);
   smtp_message_reset_status (message);  /* this is needed to plug a 28-byte/message memory leak in libesmtp */
   smtp_destroy_session (session);
   GNUNET_mutex_unlock (lock);
@@ -720,11 +718,11 @@ static int
 api_disconnect (GNUNET_TSession * tsession)
 {
   if (tsession != NULL)
-    {
-      if (tsession->internal != NULL)
-        GNUNET_free (tsession->internal);
-      GNUNET_free (tsession);
-    }
+  {
+    if (tsession->internal != NULL)
+      GNUNET_free (tsession->internal);
+    GNUNET_free (tsession);
+  }
   return GNUNET_OK;
 }
 
@@ -737,15 +735,14 @@ api_start_transport_server ()
 {
   smtp_shutdown = GNUNET_NO;
   /* initialize SMTP network */
-  dispatchThread =
-    GNUNET_thread_create (&listenAndDistribute, NULL, 1024 * 4);
+  dispatchThread = GNUNET_thread_create (&listenAndDistribute, NULL, 1024 * 4);
   if (dispatchThread == NULL)
-    {
-      GNUNET_GE_DIE_STRERROR (ectx,
-                              GNUNET_GE_ADMIN | GNUNET_GE_BULK |
-                              GNUNET_GE_FATAL, "pthread_create");
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_GE_DIE_STRERROR (ectx,
+                            GNUNET_GE_ADMIN | GNUNET_GE_BULK |
+                            GNUNET_GE_FATAL, "pthread_create");
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -809,13 +806,13 @@ inittransport_smtp (GNUNET_CoreAPIForTransport * core)
   coreAPI = core;
   ectx = core->ectx;
   if (!GNUNET_GC_have_configuration_value (coreAPI->cfg, "SMTP", "EMAIL"))
-    {
-      GNUNET_GE_LOG (ectx,
-                     GNUNET_GE_ERROR | GNUNET_GE_BULK | GNUNET_GE_USER,
-                     _
-                     ("No email-address specified, can not start SMTP transport.\n"));
-      return NULL;
-    }
+  {
+    GNUNET_GE_LOG (ectx,
+                   GNUNET_GE_ERROR | GNUNET_GE_BULK | GNUNET_GE_USER,
+                   _
+                   ("No email-address specified, can not start SMTP transport.\n"));
+    return NULL;
+  }
   GNUNET_GC_get_configuration_value_number (coreAPI->cfg,
                                             "SMTP",
                                             "MTU",
@@ -828,13 +825,13 @@ inittransport_smtp (GNUNET_CoreAPIForTransport * core)
                                             0, 0, 1024 * 1024, &rate_limit);
   stats = coreAPI->service_request ("stats");
   if (stats != NULL)
-    {
-      stat_bytesReceived
+  {
+    stat_bytesReceived
         = stats->create (gettext_noop ("# bytes received via SMTP"));
-      stat_bytesSent = stats->create (gettext_noop ("# bytes sent via SMTP"));
-      stat_bytesDropped
+    stat_bytesSent = stats->create (gettext_noop ("# bytes sent via SMTP"));
+    stat_bytesDropped
         = stats->create (gettext_noop ("# bytes dropped by SMTP (outgoing)"));
-    }
+  }
   GNUNET_GC_get_configuration_value_filename (coreAPI->cfg,
                                               "SMTP",
                                               "PIPE",
@@ -842,17 +839,17 @@ inittransport_smtp (GNUNET_CoreAPIForTransport * core)
                                               "/smtp-pipe", &pipename);
   UNLINK (pipename);
   if (0 != mkfifo (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH))
-    {
-      GNUNET_GE_LOG_STRERROR (ectx,
-                              GNUNET_GE_ADMIN | GNUNET_GE_BULK |
-                              GNUNET_GE_FATAL, "mkfifo");
-      GNUNET_free (pipename);
-      coreAPI->service_release (stats);
-      stats = NULL;
-      return NULL;
-    }
+  {
+    GNUNET_GE_LOG_STRERROR (ectx,
+                            GNUNET_GE_ADMIN | GNUNET_GE_BULK |
+                            GNUNET_GE_FATAL, "mkfifo");
+    GNUNET_free (pipename);
+    coreAPI->service_release (stats);
+    stats = NULL;
+    return NULL;
+  }
   /* we need to allow the mailer program to send us messages;
-     easiest done by giving it write permissions (see Mantis #1142) */
+   * easiest done by giving it write permissions (see Mantis #1142) */
   if (0 != chmod (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH))
     GNUNET_GE_LOG_STRERROR (ectx,
                             GNUNET_GE_ADMIN | GNUNET_GE_BULK |
@@ -863,8 +860,7 @@ inittransport_smtp (GNUNET_CoreAPIForTransport * core)
   GNUNET_GC_get_configuration_value_string (coreAPI->cfg,
                                             "SMTP",
                                             "SERVER",
-                                            "localhost:25",
-                                            &smtp_server_name);
+                                            "localhost:25", &smtp_server_name);
   sa.sa_handler = SIG_IGN;
   sigemptyset (&sa.sa_mask);
   sa.sa_flags = 0;
@@ -892,10 +888,10 @@ donetransport_smtp ()
   sigaction (SIGPIPE, &old_handler, NULL);
   GNUNET_free (smtp_server_name);
   if (stats != NULL)
-    {
-      coreAPI->service_release (stats);
-      stats = NULL;
-    }
+  {
+    coreAPI->service_release (stats);
+    stats = NULL;
+  }
   GNUNET_mutex_destroy (lock);
   lock = NULL;
   UNLINK (pipename);
diff --git a/src/transport/plugin_transport_tcp.c b/src/transport/plugin_transport_tcp.c
index 2c20ba35e..bd2f4aa6a 100644
--- a/src/transport/plugin_transport_tcp.c
+++ b/src/transport/plugin_transport_tcp.c
@@ -343,7 +343,7 @@ struct Plugin
    * Map of peers we have tried to contact behind a NAT
    */
   struct GNUNET_CONTAINER_MultiHashMap *nat_wait_conns;
-  
+
   /**
    * List of active TCP probes.
    */
@@ -358,7 +358,7 @@ struct Plugin
    * Handle for (DYN)DNS lookup of our external IP.
    */
   struct GNUNET_RESOLVER_RequestHandle *ext_dns;
-  
+
   /**
    * How many more TCP sessions are we allowed to open right now?
    */
@@ -397,9 +397,8 @@ struct Plugin
  */
 static int
 plugin_tcp_access_check (void *cls,
-                         const struct GNUNET_CONNECTION_Credentials *ucred,
-                         const struct sockaddr *addr,
-                         socklen_t addrlen)
+                         const struct GNUNET_CONNECTION_Credentials *ucred,
+                         const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
 
@@ -421,9 +420,8 @@ plugin_tcp_access_check (void *cls,
  */
 static void
 tcp_nat_port_map_callback (void *cls,
-                           int add_remove,
-                           const struct sockaddr *addr,
-                           socklen_t addrlen)
+                           int add_remove,
+                           const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct IPv4TcpAddress t4;
@@ -432,37 +430,34 @@ tcp_nat_port_map_callback (void *cls,
   size_t args;
 
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
-                   "NPMC called with %d for address `%s'\n",
-                   add_remove,
-                   GNUNET_a2s (addr, addrlen));
+                   "tcp",
+                   "NPMC called with %d for address `%s'\n",
+                   add_remove, GNUNET_a2s (addr, addrlen));
   /* convert 'addr' to our internal format */
   switch (addr->sa_family)
-    {
-    case AF_INET:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
-      t4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
-      t4.t4_port = ((struct sockaddr_in *) addr)->sin_port;
-      arg = &t4;
-      args = sizeof (t4);
-      break;
-    case AF_INET6:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
-      memcpy (&t6.ipv6_addr,
-              &((struct sockaddr_in6 *) addr)->sin6_addr,
-              sizeof (struct in6_addr));
-      t6.t6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
-      arg = &t6;
-      args = sizeof (t6);    
-      break;
-    default:
-      GNUNET_break (0);
-      return;
-    }
+  {
+  case AF_INET:
+    GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+    t4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
+    t4.t4_port = ((struct sockaddr_in *) addr)->sin_port;
+    arg = &t4;
+    args = sizeof (t4);
+    break;
+  case AF_INET6:
+    GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
+    memcpy (&t6.ipv6_addr,
+            &((struct sockaddr_in6 *) addr)->sin6_addr,
+            sizeof (struct in6_addr));
+    t6.t6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
+    arg = &t6;
+    args = sizeof (t6);
+    break;
+  default:
+    GNUNET_break (0);
+    return;
+  }
   /* modify our published address list */
-  plugin->env->notify_address (plugin->env->cls,
-                               add_remove,
-                               arg, args);
+  plugin->env->notify_address (plugin->env->cls, add_remove, arg, args);
 }
 
 
@@ -477,10 +472,8 @@ tcp_nat_port_map_callback (void *cls,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-tcp_address_to_string (void *cls,
-                       const void *addr,
-                       size_t addrlen)
+static const char *
+tcp_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   static char rbuf[INET6_ADDRSTRLEN + 12];
   char buf[INET6_ADDRSTRLEN];
@@ -493,40 +486,38 @@ tcp_address_to_string (void *cls,
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6TcpAddress))
-    {
-      t6 = addr;
-      af = AF_INET6;
-      port = ntohs (t6->t6_port);
-      memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
-      sb = &a6;
-    }
+  {
+    t6 = addr;
+    af = AF_INET6;
+    port = ntohs (t6->t6_port);
+    memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
+    sb = &a6;
+  }
   else if (addrlen == sizeof (struct IPv4TcpAddress))
-    {
-      t4 = addr;
-      af = AF_INET;
-      port = ntohs (t4->t4_port);
-      memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
-      sb = &a4;
-    }
+  {
+    t4 = addr;
+    af = AF_INET;
+    port = ntohs (t4->t4_port);
+    memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
+    sb = &a4;
+  }
   else
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "tcp",
-                       _("Unexpected address length: %u bytes\n"),
-                       (unsigned int) addrlen);
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "tcp",
+                     _("Unexpected address length: %u bytes\n"),
+                     (unsigned int) addrlen);
+    GNUNET_break (0);
+    return NULL;
+  }
   if (NULL == inet_ntop (af, sb, buf, INET6_ADDRSTRLEN))
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
-      return NULL;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
+    return NULL;
+  }
   GNUNET_snprintf (rbuf,
-                   sizeof (rbuf),
-                   (af == AF_INET6) ? "[%s]:%u" : "%s:%u",
-                   buf,
-                   port);
+                   sizeof (rbuf),
+                   (af == AF_INET6) ? "[%s]:%u" : "%s:%u", buf, port);
   return rbuf;
 }
 
@@ -565,8 +556,7 @@ find_session_by_client (struct Plugin *plugin,
 static struct Session *
 create_session (struct Plugin *plugin,
                 const struct GNUNET_PeerIdentity *target,
-                struct GNUNET_SERVER_Client *client, 
-                int is_nat)
+                struct GNUNET_SERVER_Client *client, int is_nat)
 {
   struct Session *ret;
   struct PendingMessage *pm;
@@ -578,24 +568,25 @@ create_session (struct Plugin *plugin,
     GNUNET_assert (client == NULL);
 #if DEBUG_TCP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
-                   "Creating new session for peer `%4s'\n",
-                   GNUNET_i2s (target));
+                   "tcp",
+                   "Creating new session for peer `%4s'\n",
+                   GNUNET_i2s (target));
 #endif
   ret = GNUNET_malloc (sizeof (struct Session));
   ret->last_activity = GNUNET_TIME_absolute_get ();
   ret->plugin = plugin;
   ret->is_nat = is_nat;
-  if (is_nat != GNUNET_YES) /* If not a NAT WAIT conn, add it to global list */
-    {
-      ret->next = plugin->sessions;
-      plugin->sessions = ret;
-    }
+  if (is_nat != GNUNET_YES)     /* If not a NAT WAIT conn, add it to global list */
+  {
+    ret->next = plugin->sessions;
+    plugin->sessions = ret;
+  }
   ret->client = client;
   ret->target = *target;
   ret->expecting_welcome = GNUNET_YES;
-  pm = GNUNET_malloc (sizeof (struct PendingMessage) + sizeof (struct WelcomeMessage));
-  pm->msg = (const char*) &pm[1];
+  pm = GNUNET_malloc (sizeof (struct PendingMessage) +
+                      sizeof (struct WelcomeMessage));
+  pm->msg = (const char *) &pm[1];
   pm->message_size = sizeof (struct WelcomeMessage);
   welcome.header.size = htons (sizeof (struct WelcomeMessage));
   welcome.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME);
@@ -603,17 +594,14 @@ create_session (struct Plugin *plugin,
   memcpy (&pm[1], &welcome, sizeof (welcome));
   pm->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# bytes currently in TCP buffers"),
-                            pm->message_size,
-                            GNUNET_NO);
+                            gettext_noop ("# bytes currently in TCP buffers"),
+                            pm->message_size, GNUNET_NO);
   GNUNET_CONTAINER_DLL_insert (ret->pending_messages_head,
-                               ret->pending_messages_tail,
-                               pm);
+                               ret->pending_messages_tail, pm);
   if (is_nat != GNUNET_YES)
     GNUNET_STATISTICS_update (plugin->env->stats,
                               gettext_noop ("# TCP sessions active"),
-                              1,
-                              GNUNET_NO);
+                              1, GNUNET_NO);
   return ret;
 }
 
@@ -655,111 +643,101 @@ do_transmit (void *cls, size_t size, void *buf)
   session->transmit_handle = NULL;
   plugin = session->plugin;
   if (buf == NULL)
-    {
+  {
 #if DEBUG_TCP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       "Timeout trying to transmit to peer `%4s', discarding message queue.\n",
-                       GNUNET_i2s (&session->target));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp",
+                     "Timeout trying to transmit to peer `%4s', discarding message queue.\n",
+                     GNUNET_i2s (&session->target));
 #endif
-      /* timeout; cancel all messages that have already expired */
-      hd = NULL;
-      tl = NULL;
-      ret = 0;
-      now = GNUNET_TIME_absolute_get ();
-      while ( (NULL != (pos = session->pending_messages_head)) &&
-              (pos->timeout.abs_value <= now.abs_value) )
-        {
-          GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
-                                       session->pending_messages_tail,
-                                       pos);
+    /* timeout; cancel all messages that have already expired */
+    hd = NULL;
+    tl = NULL;
+    ret = 0;
+    now = GNUNET_TIME_absolute_get ();
+    while ((NULL != (pos = session->pending_messages_head)) &&
+           (pos->timeout.abs_value <= now.abs_value))
+    {
+      GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
+                                   session->pending_messages_tail, pos);
 #if DEBUG_TCP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                           "tcp",
-                           "Failed to transmit %u byte message to `%4s'.\n",
-                           pos->message_size,
-                           GNUNET_i2s (&session->target));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "tcp",
+                       "Failed to transmit %u byte message to `%4s'.\n",
+                       pos->message_size, GNUNET_i2s (&session->target));
 #endif
-          ret += pos->message_size;
-          GNUNET_CONTAINER_DLL_insert_after (hd, tl, tl, pos);
-        }
-      /* do this call before callbacks (so that if callbacks destroy
-         session, they have a chance to cancel actions done by this
-         call) */
-      process_pending_messages (session);
-      pid = session->target;
-      /* no do callbacks and do not use session again since
-         the callbacks may abort the session */
-      while (NULL != (pos = hd))
-        {
-          GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
-          if (pos->transmit_cont != NULL)
-            pos->transmit_cont (pos->transmit_cont_cls,
-                                &pid, GNUNET_SYSERR);
-          GNUNET_free (pos);
-        }
-      GNUNET_STATISTICS_update (plugin->env->stats,
-                                gettext_noop ("# bytes currently in TCP buffers"),
-                                - (int64_t) ret,
-                                GNUNET_NO);
-      GNUNET_STATISTICS_update (plugin->env->stats,
-                                gettext_noop ("# bytes discarded by TCP (timeout)"),
-                                ret,
-                                GNUNET_NO);
-      return 0;
+      ret += pos->message_size;
+      GNUNET_CONTAINER_DLL_insert_after (hd, tl, tl, pos);
+    }
+    /* do this call before callbacks (so that if callbacks destroy
+     * session, they have a chance to cancel actions done by this
+     * call) */
+    process_pending_messages (session);
+    pid = session->target;
+    /* no do callbacks and do not use session again since
+     * the callbacks may abort the session */
+    while (NULL != (pos = hd))
+    {
+      GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
+      if (pos->transmit_cont != NULL)
+        pos->transmit_cont (pos->transmit_cont_cls, &pid, GNUNET_SYSERR);
+      GNUNET_free (pos);
     }
+    GNUNET_STATISTICS_update (plugin->env->stats,
+                              gettext_noop ("# bytes currently in TCP buffers"),
+                              -(int64_t) ret, GNUNET_NO);
+    GNUNET_STATISTICS_update (plugin->env->stats,
+                              gettext_noop
+                              ("# bytes discarded by TCP (timeout)"), ret,
+                              GNUNET_NO);
+    return 0;
+  }
   /* copy all pending messages that would fit */
   ret = 0;
   cbuf = buf;
   hd = NULL;
   tl = NULL;
   while (NULL != (pos = session->pending_messages_head))
-    {
-      if (ret + pos->message_size > size)
-        break;
-      GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
-                                   session->pending_messages_tail,
-                                   pos);
-      GNUNET_assert (size >= pos->message_size);
-      /* FIXME: this memcpy can be up to 7% of our total runtime */
-      memcpy (cbuf, pos->msg, pos->message_size);
-      cbuf += pos->message_size;
-      ret += pos->message_size;
-      size -= pos->message_size;
-      GNUNET_CONTAINER_DLL_insert_after (hd, tl, tl, pos);
-    }
+  {
+    if (ret + pos->message_size > size)
+      break;
+    GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
+                                 session->pending_messages_tail, pos);
+    GNUNET_assert (size >= pos->message_size);
+    /* FIXME: this memcpy can be up to 7% of our total runtime */
+    memcpy (cbuf, pos->msg, pos->message_size);
+    cbuf += pos->message_size;
+    ret += pos->message_size;
+    size -= pos->message_size;
+    GNUNET_CONTAINER_DLL_insert_after (hd, tl, tl, pos);
+  }
   /* schedule 'continuation' before callbacks so that callbacks that
-     cancel everything don't cause us to use a session that no longer
-     exists... */
+   * cancel everything don't cause us to use a session that no longer
+   * exists... */
   process_pending_messages (session);
   session->last_activity = GNUNET_TIME_absolute_get ();
   pid = session->target;
   /* we'll now call callbacks that may cancel the session; hence
-     we should not use 'session' after this point */
+   * we should not use 'session' after this point */
   while (NULL != (pos = hd))
-    {
-      GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
-      if (pos->transmit_cont != NULL)
-        pos->transmit_cont (pos->transmit_cont_cls,
-                            &pid, GNUNET_OK);
-      GNUNET_free (pos);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (hd, tl, pos);
+    if (pos->transmit_cont != NULL)
+      pos->transmit_cont (pos->transmit_cont_cls, &pid, GNUNET_OK);
+    GNUNET_free (pos);
+  }
   GNUNET_assert (hd == NULL);
   GNUNET_assert (tl == NULL);
 #if DEBUG_TCP > 1
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
-                   "Transmitting %u bytes\n", 
-                   ret);
+                   "tcp", "Transmitting %u bytes\n", ret);
 #endif
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# bytes currently in TCP buffers"),
-                            - (int64_t) ret,
-                            GNUNET_NO);
+                            gettext_noop ("# bytes currently in TCP buffers"),
+                            -(int64_t) ret, GNUNET_NO);
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# bytes transmitted via TCP"),
-                            ret,
-                            GNUNET_NO);
+                            gettext_noop ("# bytes transmitted via TCP"),
+                            ret, GNUNET_NO);
   return ret;
 }
 
@@ -782,11 +760,11 @@ process_pending_messages (struct Session *session)
     return;
 
   session->transmit_handle
-    = GNUNET_SERVER_notify_transmit_ready (session->client,
-                                           pm->message_size,
-                                           GNUNET_TIME_absolute_get_remaining
-                                           (pm->timeout),
-                                           &do_transmit, session);
+      = GNUNET_SERVER_notify_transmit_ready (session->client,
+                                             pm->message_size,
+                                             GNUNET_TIME_absolute_get_remaining
+                                             (pm->timeout),
+                                             &do_transmit, session);
 }
 
 
@@ -806,22 +784,22 @@ disconnect_session (struct Session *session)
 
 #if DEBUG_TCP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
+                   "tcp",
                    "Disconnecting from `%4s' at %s.\n",
                    GNUNET_i2s (&session->target),
                    (session->connect_addr != NULL) ?
                    tcp_address_to_string (session->plugin,
-                                          session->connect_addr,
-                                          session->connect_alen) : "*");
+                                          session->connect_addr,
+                                          session->connect_alen) : "*");
 #endif
   /* remove from session list */
   prev = NULL;
   pos = session->plugin->sessions;
   while (pos != session)
-    {
-      prev = pos;
-      pos = pos->next;
-    }
+  {
+    prev = pos;
+    pos = pos->next;
+  }
   if (prev == NULL)
     session->plugin->sessions = session->next;
   else
@@ -829,57 +807,51 @@ disconnect_session (struct Session *session)
 
   /* clean up state */
   if (session->transmit_handle != NULL)
-    {
-      GNUNET_CONNECTION_notify_transmit_ready_cancel
-        (session->transmit_handle);
-      session->transmit_handle = NULL;
-    }
+  {
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (session->transmit_handle);
+    session->transmit_handle = NULL;
+  }
   session->plugin->env->session_end (session->plugin->env->cls,
-                                     &session->target,
-                                     session);
+                                     &session->target, session);
   while (NULL != (pm = session->pending_messages_head))
-    {
+  {
 #if DEBUG_TCP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       pm->transmit_cont != NULL
-                       ? "Could not deliver message to `%4s'.\n"
-                       : "Could not deliver message to `%4s', notifying.\n",
-                       GNUNET_i2s (&session->target));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp",
+                     pm->transmit_cont != NULL
+                     ? "Could not deliver message to `%4s'.\n"
+                     : "Could not deliver message to `%4s', notifying.\n",
+                     GNUNET_i2s (&session->target));
 #endif
-      GNUNET_STATISTICS_update (session->plugin->env->stats,
-                                gettext_noop ("# bytes currently in TCP buffers"),
-                                - (int64_t) pm->message_size,
-                                GNUNET_NO);
-      GNUNET_STATISTICS_update (session->plugin->env->stats,
-                                gettext_noop ("# bytes discarded by TCP (disconnect)"),
-                                pm->message_size,
-                                GNUNET_NO);
-      GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
-                                   session->pending_messages_tail,
-                                   pm);
-      if (NULL != pm->transmit_cont)
-        pm->transmit_cont (pm->transmit_cont_cls,
-                           &session->target, GNUNET_SYSERR);
-      GNUNET_free (pm);
-    }
+    GNUNET_STATISTICS_update (session->plugin->env->stats,
+                              gettext_noop ("# bytes currently in TCP buffers"),
+                              -(int64_t) pm->message_size, GNUNET_NO);
+    GNUNET_STATISTICS_update (session->plugin->env->stats,
+                              gettext_noop
+                              ("# bytes discarded by TCP (disconnect)"),
+                              pm->message_size, GNUNET_NO);
+    GNUNET_CONTAINER_DLL_remove (session->pending_messages_head,
+                                 session->pending_messages_tail, pm);
+    if (NULL != pm->transmit_cont)
+      pm->transmit_cont (pm->transmit_cont_cls,
+                         &session->target, GNUNET_SYSERR);
+    GNUNET_free (pm);
+  }
   GNUNET_break (session->client != NULL);
   if (session->receive_delay_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (session->receive_delay_task);
-      if (session->client != NULL)
-        GNUNET_SERVER_receive_done (session->client,
-                                    GNUNET_SYSERR);     
-    }
+  {
+    GNUNET_SCHEDULER_cancel (session->receive_delay_task);
+    if (session->client != NULL)
+      GNUNET_SERVER_receive_done (session->client, GNUNET_SYSERR);
+  }
   if (session->client != NULL)
-    {
-      GNUNET_SERVER_client_drop (session->client);
-      session->client = NULL;
-    }
+  {
+    GNUNET_SERVER_client_drop (session->client);
+    session->client = NULL;
+  }
   GNUNET_STATISTICS_update (session->plugin->env->stats,
-                            gettext_noop ("# TCP sessions active"),
-                            -1,
-                            GNUNET_NO);
+                            gettext_noop ("# TCP sessions active"),
+                            -1, GNUNET_NO);
   GNUNET_free_non_null (session->connect_addr);
   GNUNET_assert (NULL == session->transmit_handle);
   GNUNET_free (session);
@@ -894,28 +866,25 @@ disconnect_session (struct Session *session)
  * @return "better" session (more active)
  */
 static struct Session *
-select_better_session (struct Session *s1,
-                       struct Session *s2)
+select_better_session (struct Session *s1, struct Session *s2)
 {
   if (s1 == NULL)
     return s2;
   if (s2 == NULL)
     return s1;
-  if ( (s1->expecting_welcome == GNUNET_NO) &&
-       (s2->expecting_welcome == GNUNET_YES) )
+  if ((s1->expecting_welcome == GNUNET_NO) &&
+      (s2->expecting_welcome == GNUNET_YES))
     return s1;
-  if ( (s1->expecting_welcome == GNUNET_YES) &&
-       (s2->expecting_welcome == GNUNET_NO) )
+  if ((s1->expecting_welcome == GNUNET_YES) &&
+      (s2->expecting_welcome == GNUNET_NO))
     return s2;
   if (s1->last_activity.abs_value < s2->last_activity.abs_value)
     return s2;
   if (s1->last_activity.abs_value > s2->last_activity.abs_value)
     return s1;
-  if ( (GNUNET_YES == s1->inbound) &&
-       (GNUNET_NO  == s2->inbound) )
+  if ((GNUNET_YES == s1->inbound) && (GNUNET_NO == s2->inbound))
     return s1;
-  if ( (GNUNET_NO  == s1->inbound) &&
-       (GNUNET_YES == s2->inbound) )
+  if ((GNUNET_NO == s1->inbound) && (GNUNET_YES == s2->inbound))
     return s2;
   return s1;
 }
@@ -965,10 +934,10 @@ tcp_plugin_send (void *cls,
                  size_t msgbuf_size,
                  uint32_t priority,
                  struct GNUNET_TIME_Relative timeout,
-                 struct Session *session,
-                 const void *addr,
-                 size_t addrlen,
-                 int force_address,
+                 struct Session *session,
+                 const void *addr,
+                 size_t addrlen,
+                 int force_address,
                  GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
   struct Plugin *plugin = cls;
@@ -986,234 +955,217 @@ tcp_plugin_send (void *cls,
   unsigned int is_natd;
 
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# bytes TCP was asked to transmit"),
-                            msgbuf_size,
-                            GNUNET_NO);
+                            gettext_noop ("# bytes TCP was asked to transmit"),
+                            msgbuf_size, GNUNET_NO);
   /* FIXME: we could do this cheaper with a hash table
-     where we could restrict the iteration to entries that match
-     the target peer... */
+   * where we could restrict the iteration to entries that match
+   * the target peer... */
   is_natd = GNUNET_NO;
   if (session == NULL)
+  {
+    cand_session = NULL;
+    next = plugin->sessions;
+    while (NULL != (session = next))
     {
-      cand_session = NULL;
-      next = plugin->sessions;
-      while (NULL != (session = next))
-        {
-          next = session->next;
-          GNUNET_assert (session->client != NULL);
-          if (0 != memcmp (target,
-                           &session->target,
-                           sizeof (struct GNUNET_PeerIdentity)))
-            continue;
-          if ( ( (GNUNET_SYSERR == force_address) &&
-                 (session->expecting_welcome == GNUNET_NO) ) ||
-               (GNUNET_NO == force_address) )
-            {
-              cand_session = select_better_session (cand_session,
-                                                    session);
-              continue;
-            }
-          if (GNUNET_SYSERR == force_address)
-            continue;
-          GNUNET_break (GNUNET_YES == force_address);
-          if (addr == NULL)
-            {
-              GNUNET_break (0);
-              break;
-            }
-          if ( (addrlen != session->connect_alen) && 
-               (session->is_nat == GNUNET_NO) )
-            continue;
-          if ((0 != memcmp (session->connect_addr,
-                           addr,
-                           addrlen)) && (session->is_nat == GNUNET_NO))
-            continue;
-          cand_session = select_better_session (cand_session,
-                                                session);       
-        }
-      session = cand_session;
+      next = session->next;
+      GNUNET_assert (session->client != NULL);
+      if (0 != memcmp (target,
+                       &session->target, sizeof (struct GNUNET_PeerIdentity)))
+        continue;
+      if (((GNUNET_SYSERR == force_address) &&
+           (session->expecting_welcome == GNUNET_NO)) ||
+          (GNUNET_NO == force_address))
+      {
+        cand_session = select_better_session (cand_session, session);
+        continue;
+      }
+      if (GNUNET_SYSERR == force_address)
+        continue;
+      GNUNET_break (GNUNET_YES == force_address);
+      if (addr == NULL)
+      {
+        GNUNET_break (0);
+        break;
+      }
+      if ((addrlen != session->connect_alen) && (session->is_nat == GNUNET_NO))
+        continue;
+      if ((0 != memcmp (session->connect_addr,
+                        addr, addrlen)) && (session->is_nat == GNUNET_NO))
+        continue;
+      cand_session = select_better_session (cand_session, session);
     }
-  if ( (session == NULL) &&
-       (addr == NULL) )
-    {
+    session = cand_session;
+  }
+  if ((session == NULL) && (addr == NULL))
+  {
 #if DEBUG_TCP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       "Asked to transmit to `%4s' without address and I have no existing connection (failing).\n",
-                       GNUNET_i2s (target));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp",
+                     "Asked to transmit to `%4s' without address and I have no existing connection (failing).\n",
+                     GNUNET_i2s (target));
 #endif
-      GNUNET_STATISTICS_update (plugin->env->stats,
-                                gettext_noop ("# bytes discarded by TCP (no address and no connection)"),
-                                msgbuf_size,
-                                GNUNET_NO);
-      return -1;
-    }
+    GNUNET_STATISTICS_update (plugin->env->stats,
+                              gettext_noop
+                              ("# bytes discarded by TCP (no address and no connection)"),
+                              msgbuf_size, GNUNET_NO);
+    return -1;
+  }
   if (session == NULL)
+  {
+    if (addrlen == sizeof (struct IPv6TcpAddress))
     {
-      if (addrlen == sizeof (struct IPv6TcpAddress))
-        {
-          t6 = addr;
-          af = AF_INET6;
-          memset (&a6, 0, sizeof (a6));
+      t6 = addr;
+      af = AF_INET6;
+      memset (&a6, 0, sizeof (a6));
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          a6.sin6_len = sizeof (a6);
+      a6.sin6_len = sizeof (a6);
 #endif
-          a6.sin6_family = AF_INET6;
-          a6.sin6_port = t6->t6_port;
-          if (t6->t6_port == 0)
-            is_natd = GNUNET_YES;
-          memcpy (&a6.sin6_addr,
-                  &t6->ipv6_addr,
-                  sizeof (struct in6_addr));
-          sb = &a6;
-          sbs = sizeof (a6);
-        }
-      else if (addrlen == sizeof (struct IPv4TcpAddress))
-        {
-          t4 = addr;
-          af = AF_INET;
-          memset (&a4, 0, sizeof (a4));
+      a6.sin6_family = AF_INET6;
+      a6.sin6_port = t6->t6_port;
+      if (t6->t6_port == 0)
+        is_natd = GNUNET_YES;
+      memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof (struct in6_addr));
+      sb = &a6;
+      sbs = sizeof (a6);
+    }
+    else if (addrlen == sizeof (struct IPv4TcpAddress))
+    {
+      t4 = addr;
+      af = AF_INET;
+      memset (&a4, 0, sizeof (a4));
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          a4.sin_len = sizeof (a4);
+      a4.sin_len = sizeof (a4);
 #endif
-          a4.sin_family = AF_INET;
-          a4.sin_port = t4->t4_port;
-          if (t4->t4_port == 0)
-            is_natd = GNUNET_YES;
-          a4.sin_addr.s_addr = t4->ipv4_addr;
-          sb = &a4;
-          sbs = sizeof (a4);
-        }
-      else
-        {
-          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                           "tcp",
-                           _("Address of unexpected length: %u\n"),
-                           addrlen);
-          GNUNET_break (0);
-          return -1;
-        }
-
-      if ((is_natd == GNUNET_YES) && (addrlen == sizeof (struct IPv6TcpAddress)))
-        return -1; /* NAT client only works with IPv4 addresses */
-      if (0 == plugin->max_connections)
-        return -1; /* saturated */
-
-      if ( (is_natd == GNUNET_YES) &&
-           (NULL != plugin->nat) &&
-           (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(plugin->nat_wait_conns,
-                                                                &target->hashPubKey)) )
-        {
+      a4.sin_family = AF_INET;
+      a4.sin_port = t4->t4_port;
+      if (t4->t4_port == 0)
+        is_natd = GNUNET_YES;
+      a4.sin_addr.s_addr = t4->ipv4_addr;
+      sb = &a4;
+      sbs = sizeof (a4);
+    }
+    else
+    {
+      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                       "tcp", _("Address of unexpected length: %u\n"), addrlen);
+      GNUNET_break (0);
+      return -1;
+    }
+
+    if ((is_natd == GNUNET_YES) && (addrlen == sizeof (struct IPv6TcpAddress)))
+      return -1;                /* NAT client only works with IPv4 addresses */
+    if (0 == plugin->max_connections)
+      return -1;                /* saturated */
+
+    if ((is_natd == GNUNET_YES) &&
+        (NULL != plugin->nat) &&
+        (GNUNET_NO ==
+         GNUNET_CONTAINER_multihashmap_contains (plugin->nat_wait_conns,
+                                                 &target->hashPubKey)))
+    {
 #if DEBUG_TCP_NAT
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                           "tcp",
-                           _("Found valid IPv4 NAT address (creating session)!\n"));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "tcp",
+                       _("Found valid IPv4 NAT address (creating session)!\n"));
 #endif
-          session = create_session (plugin,
-                                    target,
-                                    NULL, 
-                                    GNUNET_YES);
-          GNUNET_assert (session != NULL);
-
-          /* create new message entry */
-          pm = GNUNET_malloc (sizeof (struct PendingMessage) + msgbuf_size);
-          /* FIXME: the memset of this malloc can be up to 2% of our total runtime */
-          pm->msg = (const char*) &pm[1];
-          memcpy (&pm[1], msg, msgbuf_size);
-          /* FIXME: this memcpy can be up to 7% of our total run-time
-             (for transport service) */
-          pm->message_size = msgbuf_size;
-          pm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
-          pm->transmit_cont = cont;
-          pm->transmit_cont_cls = cont_cls;
-
-          /* append pm to pending_messages list */
-          GNUNET_CONTAINER_DLL_insert_after (session->pending_messages_head,
-                                             session->pending_messages_tail,
-                                             session->pending_messages_tail,
-                                             pm);
-
-          GNUNET_assert(GNUNET_CONTAINER_multihashmap_put(plugin->nat_wait_conns,
-                                                          &target->hashPubKey,
-                                                          session, 
-                                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY) == GNUNET_OK);
+      session = create_session (plugin, target, NULL, GNUNET_YES);
+      GNUNET_assert (session != NULL);
+
+      /* create new message entry */
+      pm = GNUNET_malloc (sizeof (struct PendingMessage) + msgbuf_size);
+      /* FIXME: the memset of this malloc can be up to 2% of our total runtime */
+      pm->msg = (const char *) &pm[1];
+      memcpy (&pm[1], msg, msgbuf_size);
+      /* FIXME: this memcpy can be up to 7% of our total run-time
+       * (for transport service) */
+      pm->message_size = msgbuf_size;
+      pm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+      pm->transmit_cont = cont;
+      pm->transmit_cont_cls = cont_cls;
+
+      /* append pm to pending_messages list */
+      GNUNET_CONTAINER_DLL_insert_after (session->pending_messages_head,
+                                         session->pending_messages_tail,
+                                         session->pending_messages_tail, pm);
+
+      GNUNET_assert (GNUNET_CONTAINER_multihashmap_put (plugin->nat_wait_conns,
+                                                        &target->hashPubKey,
+                                                        session,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                     == GNUNET_OK);
 #if DEBUG_TCP_NAT
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                           "tcp",
-                           "Created NAT WAIT connection to `%4s' at `%s'\n",
-                           GNUNET_i2s (target),
-                           GNUNET_a2s (sb, sbs));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "tcp",
+                       "Created NAT WAIT connection to `%4s' at `%s'\n",
+                       GNUNET_i2s (target), GNUNET_a2s (sb, sbs));
 #endif
-          GNUNET_NAT_run_client (plugin->nat, &a4);
-          return 0;
-        }
-      if ( (is_natd == GNUNET_YES) && 
-           (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(plugin->nat_wait_conns, 
-                                                                 &target->hashPubKey)) )
-        {
-          /* Only do one NAT punch attempt per peer identity */
-          return -1;
-        }
-      sa = GNUNET_CONNECTION_create_from_sockaddr (af, sb, sbs);
-      if (sa == NULL)
-        {
+      GNUNET_NAT_run_client (plugin->nat, &a4);
+      return 0;
+    }
+    if ((is_natd == GNUNET_YES) &&
+        (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_contains (plugin->nat_wait_conns,
+                                                 &target->hashPubKey)))
+    {
+      /* Only do one NAT punch attempt per peer identity */
+      return -1;
+    }
+    sa = GNUNET_CONNECTION_create_from_sockaddr (af, sb, sbs);
+    if (sa == NULL)
+    {
 #if DEBUG_TCP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                           "tcp",
-                           "Failed to create connection to `%4s' at `%s'\n",
-                           GNUNET_i2s (target),
-                           GNUNET_a2s (sb, sbs));
-#endif
-          GNUNET_STATISTICS_update (plugin->env->stats,
-                                    gettext_noop ("# bytes discarded by TCP (failed to connect)"),
-                                    msgbuf_size,
-                                    GNUNET_NO);
-          return -1;
-        }
-      GNUNET_assert (0 != plugin->max_connections);
-      plugin->max_connections--;
-#if DEBUG_TCP_NAT
       GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       "Asked to transmit to `%4s', creating fresh session using address `%s'.\n",
-                       GNUNET_i2s (target),
-                       GNUNET_a2s (sb, sbs));
+                       "tcp",
+                       "Failed to create connection to `%4s' at `%s'\n",
+                       GNUNET_i2s (target), GNUNET_a2s (sb, sbs));
 #endif
-      session = create_session (plugin,
-                                target,
-                                GNUNET_SERVER_connect_socket (plugin->server,
-                                                              sa), 
-                                GNUNET_NO);
-      session->connect_addr = GNUNET_malloc (addrlen);
-      memcpy (session->connect_addr,
-              addr,
-              addrlen);
-      session->connect_alen = addrlen;
+      GNUNET_STATISTICS_update (plugin->env->stats,
+                                gettext_noop
+                                ("# bytes discarded by TCP (failed to connect)"),
+                                msgbuf_size, GNUNET_NO);
+      return -1;
     }
-  else  /* session != NULL */
+    GNUNET_assert (0 != plugin->max_connections);
+    plugin->max_connections--;
+#if DEBUG_TCP_NAT
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp",
+                     "Asked to transmit to `%4s', creating fresh session using address `%s'.\n",
+                     GNUNET_i2s (target), GNUNET_a2s (sb, sbs));
+#endif
+    session = create_session (plugin,
+                              target,
+                              GNUNET_SERVER_connect_socket (plugin->server,
+                                                            sa), GNUNET_NO);
+    session->connect_addr = GNUNET_malloc (addrlen);
+    memcpy (session->connect_addr, addr, addrlen);
+    session->connect_alen = addrlen;
+  }
+  else                          /* session != NULL */
+  {
+    /* check if session is valid */
+    struct Session *ses = plugin->sessions;
+
+    while ((ses != NULL) && (ses != session))
+      ses = ses->next;
+    if (ses == NULL)
     {
-      /* check if session is valid */
-      struct Session * ses = plugin->sessions;
-      while ((ses != NULL) && (ses != session))
-        ses = ses->next;
-      if (ses == NULL)
-        {
-          GNUNET_break (0);
-          return -1;
-        }
+      GNUNET_break (0);
+      return -1;
     }
+  }
   GNUNET_assert (session != NULL);
   GNUNET_assert (session->client != NULL);
 
 
-  GNUNET_SERVER_client_set_timeout(session->client, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  GNUNET_SERVER_client_set_timeout (session->client,
+                                    GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# bytes currently in TCP buffers"),
-                            msgbuf_size,
-                            GNUNET_NO);
+                            gettext_noop ("# bytes currently in TCP buffers"),
+                            msgbuf_size, GNUNET_NO);
   /* create new message entry */
   pm = GNUNET_malloc (sizeof (struct PendingMessage) + msgbuf_size);
-  pm->msg = (const char*) &pm[1];
+  pm->msg = (const char *) &pm[1];
   memcpy (&pm[1], msg, msgbuf_size);
   pm->message_size = msgbuf_size;
   pm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
@@ -1222,15 +1174,13 @@ tcp_plugin_send (void *cls,
 
   /* append pm to pending_messages list */
   GNUNET_CONTAINER_DLL_insert_after (session->pending_messages_head,
-                                     session->pending_messages_tail,
-                                     session->pending_messages_tail,
-                                     pm);
+                                     session->pending_messages_tail,
+                                     session->pending_messages_tail, pm);
 #if DEBUG_TCP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
-                   "Asked to transmit %u bytes to `%s', added message to list.\n",
-                   msgbuf_size,
-                   GNUNET_i2s (target));
+                   "tcp",
+                   "Asked to transmit %u bytes to `%s', added message to list.\n",
+                   msgbuf_size, GNUNET_i2s (target));
 #endif
   process_pending_messages (session);
   return msgbuf_size;
@@ -1254,8 +1204,7 @@ tcp_plugin_send (void *cls,
  *        to be cancelled
  */
 static void
-tcp_plugin_disconnect (void *cls,
-                       const struct GNUNET_PeerIdentity *target)
+tcp_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
 {
   struct Plugin *plugin = cls;
   struct Session *session;
@@ -1264,31 +1213,29 @@ tcp_plugin_disconnect (void *cls,
 
 #if DEBUG_TCP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
-                   "Asked to cancel session with `%4s'\n",
-                   GNUNET_i2s (target));
+                   "tcp",
+                   "Asked to cancel session with `%4s'\n", GNUNET_i2s (target));
 #endif
   next = plugin->sessions;
   while (NULL != (session = next))
+  {
+    next = session->next;
+    if (0 != memcmp (target,
+                     &session->target, sizeof (struct GNUNET_PeerIdentity)))
+      continue;
+    pm = session->pending_messages_head;
+    while (pm != NULL)
     {
-      next = session->next;
-      if (0 != memcmp (target,
-                       &session->target,
-                       sizeof (struct GNUNET_PeerIdentity)))
-        continue;
-      pm = session->pending_messages_head;
-      while (pm != NULL)
-        {
-          pm->transmit_cont = NULL;
-          pm->transmit_cont_cls = NULL;
-          pm = pm->next;
-        }
-      GNUNET_STATISTICS_update (session->plugin->env->stats,
-                                gettext_noop ("# transport-service disconnect requests for TCP"),
-                                1,
-                                GNUNET_NO);
-      disconnect_session (session);
+      pm->transmit_cont = NULL;
+      pm->transmit_cont_cls = NULL;
+      pm = pm->next;
     }
+    GNUNET_STATISTICS_update (session->plugin->env->stats,
+                              gettext_noop
+                              ("# transport-service disconnect requests for TCP"),
+                              1, GNUNET_NO);
+    disconnect_session (session);
+  }
 }
 
 
@@ -1327,11 +1274,11 @@ append_port (void *cls, const char *hostname)
   char *ret;
 
   if (hostname == NULL)
-    {
-      ppc->asc (ppc->asc_cls, NULL);
-      GNUNET_free (ppc);
-      return;
-    }
+  {
+    ppc->asc (ppc->asc_cls, NULL);
+    GNUNET_free (ppc);
+    return;
+  }
   GNUNET_asprintf (&ret, "%s:%d", hostname, ppc->port);
   ppc->asc (ppc->asc_cls, ret);
   GNUNET_free (ret);
@@ -1372,43 +1319,39 @@ tcp_plugin_address_pretty_printer (void *cls,
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6TcpAddress))
-    {
-      t6 = addr;
-      memset (&a6, 0, sizeof (a6));
-      a6.sin6_family = AF_INET6;
-      a6.sin6_port = t6->t6_port;
-      memcpy (&a6.sin6_addr,
-              &t6->ipv6_addr,
-              sizeof (struct in6_addr));
-      port = ntohs (t6->t6_port);
-      sb = &a6;
-      sbs = sizeof (a6);
-    }
+  {
+    t6 = addr;
+    memset (&a6, 0, sizeof (a6));
+    a6.sin6_family = AF_INET6;
+    a6.sin6_port = t6->t6_port;
+    memcpy (&a6.sin6_addr, &t6->ipv6_addr, sizeof (struct in6_addr));
+    port = ntohs (t6->t6_port);
+    sb = &a6;
+    sbs = sizeof (a6);
+  }
   else if (addrlen == sizeof (struct IPv4TcpAddress))
-    {
-      t4 = addr;
-      memset (&a4, 0, sizeof (a4));
-      a4.sin_family = AF_INET;
-      a4.sin_port = t4->t4_port;
-      a4.sin_addr.s_addr = t4->ipv4_addr;
-      port = ntohs (t4->t4_port);
-      sb = &a4;
-      sbs = sizeof (a4);
-    }
+  {
+    t4 = addr;
+    memset (&a4, 0, sizeof (a4));
+    a4.sin_family = AF_INET;
+    a4.sin_port = t4->t4_port;
+    a4.sin_addr.s_addr = t4->ipv4_addr;
+    port = ntohs (t4->t4_port);
+    sb = &a4;
+    sbs = sizeof (a4);
+  }
   else
-    {
-      /* invalid address */
-      GNUNET_break_op (0);
-      asc (asc_cls, NULL);
-      return;
-    }
+  {
+    /* invalid address */
+    GNUNET_break_op (0);
+    asc (asc_cls, NULL);
+    return;
+  }
   ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext));
   ppc->asc = asc;
   ppc->asc_cls = asc_cls;
   ppc->port = port;
-  GNUNET_RESOLVER_hostname_get (sb,
-                                sbs,
-                                !numeric, timeout, &append_port, ppc);
+  GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
 }
 
 
@@ -1423,8 +1366,7 @@ tcp_plugin_address_pretty_printer (void *cls,
  * @return GNUNET_OK if port is either open_port or adv_port
  */
 static int
-check_port (struct Plugin *plugin, 
-            uint16_t in_port)
+check_port (struct Plugin *plugin, uint16_t in_port)
 {
   if ((in_port == plugin->adv_port) || (in_port == plugin->open_port))
     return GNUNET_OK;
@@ -1448,9 +1390,7 @@ check_port (struct Plugin *plugin,
  *         and transport, GNUNET_SYSERR if not
  */
 static int
-tcp_plugin_check_address (void *cls,
-                          const void *addr,
-                          size_t addrlen)
+tcp_plugin_check_address (void *cls, const void *addr, size_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct IPv4TcpAddress *v4;
@@ -1458,37 +1398,35 @@ tcp_plugin_check_address (void *cls,
 
   if ((addrlen != sizeof (struct IPv4TcpAddress)) &&
       (addrlen != sizeof (struct IPv6TcpAddress)))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   if (addrlen == sizeof (struct IPv4TcpAddress))
-    {
-      v4 = (struct IPv4TcpAddress *) addr;
-      if (GNUNET_OK !=
-          check_port (plugin, ntohs (v4->t4_port)))
-        return GNUNET_SYSERR;
-      if (GNUNET_OK !=
-          GNUNET_NAT_test_address (plugin->nat,
-                                   &v4->ipv4_addr, sizeof (struct in_addr)))
-        return GNUNET_SYSERR;   
-    }
+  {
+    v4 = (struct IPv4TcpAddress *) addr;
+    if (GNUNET_OK != check_port (plugin, ntohs (v4->t4_port)))
+      return GNUNET_SYSERR;
+    if (GNUNET_OK !=
+        GNUNET_NAT_test_address (plugin->nat,
+                                 &v4->ipv4_addr, sizeof (struct in_addr)))
+      return GNUNET_SYSERR;
+  }
   else
+  {
+    v6 = (struct IPv6TcpAddress *) addr;
+    if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
     {
-      v6 = (struct IPv6TcpAddress *) addr;
-      if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
-        {
-          GNUNET_break_op (0);
-          return GNUNET_SYSERR;
-        }
-      if (GNUNET_OK !=
-          check_port (plugin, ntohs (v6->t6_port)))
-        return GNUNET_SYSERR;
-      if (GNUNET_OK !=
-          GNUNET_NAT_test_address (plugin->nat,
-                                   &v6->ipv6_addr, sizeof (struct in6_addr)))
-        return GNUNET_SYSERR;
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
     }
+    if (GNUNET_OK != check_port (plugin, ntohs (v6->t6_port)))
+      return GNUNET_SYSERR;
+    if (GNUNET_OK !=
+        GNUNET_NAT_test_address (plugin->nat,
+                                 &v6->ipv6_addr, sizeof (struct in6_addr)))
+      return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -1504,8 +1442,8 @@ tcp_plugin_check_address (void *cls,
  */
 static void
 handle_tcp_nat_probe (void *cls,
-                      struct GNUNET_SERVER_Client *client,
-                      const struct GNUNET_MessageHeader *message)
+                      struct GNUNET_SERVER_Client *client,
+                      const struct GNUNET_MessageHeader *message)
 {
   struct Plugin *plugin = cls;
   struct Session *session;
@@ -1518,9 +1456,7 @@ handle_tcp_nat_probe (void *cls,
   const struct sockaddr_in6 *s6;
 
 #if DEBUG_TCP_NAT
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, 
-                   "tcp",
-                   "received NAT probe\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "tcp", "received NAT probe\n");
 #endif
   /* We have received a TCP NAT probe, meaning we (hopefully) initiated
    * a connection to this peer by running gnunet-nat-client.  This peer
@@ -1528,51 +1464,49 @@ handle_tcp_nat_probe (void *cls,
    * as the default for that peer.  Do so and then send a WELCOME message
    * so we can really be connected!
    */
-  if (ntohs(message->size) != sizeof(struct TCP_NAT_ProbeMessage))
-    {
-      GNUNET_break_op(0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  if (ntohs (message->size) != sizeof (struct TCP_NAT_ProbeMessage))
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
 
-  tcp_nat_probe = (const struct TCP_NAT_ProbeMessage *)message;
+  tcp_nat_probe = (const struct TCP_NAT_ProbeMessage *) message;
   if (0 == memcmp (&tcp_nat_probe->clientIdentity,
                    plugin->env->my_identity,
                    sizeof (struct GNUNET_PeerIdentity)))
-    {
-      /* refuse connections from ourselves */
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    /* refuse connections from ourselves */
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
 
-  session = GNUNET_CONTAINER_multihashmap_get(plugin->nat_wait_conns, 
-                                              &tcp_nat_probe->clientIdentity.hashPubKey);
+  session = GNUNET_CONTAINER_multihashmap_get (plugin->nat_wait_conns,
+                                               &tcp_nat_probe->
+                                               clientIdentity.hashPubKey);
   if (session == NULL)
-    {
+  {
 #if DEBUG_TCP_NAT
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       "Did NOT find session for NAT probe!\n");
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp", "Did NOT find session for NAT probe!\n");
 #endif
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
 #if DEBUG_TCP_NAT
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, 
-                   "tcp",
-                   "Found session for NAT probe!\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "tcp", "Found session for NAT probe!\n");
 #endif
-  GNUNET_assert(GNUNET_CONTAINER_multihashmap_remove(plugin->nat_wait_conns, 
-                                                     &tcp_nat_probe->clientIdentity.hashPubKey,
-                                                     session) == GNUNET_YES);
-  if (GNUNET_OK !=
-      GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
-    {
-      GNUNET_break (0);
-      GNUNET_free (session);
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+  GNUNET_assert (GNUNET_CONTAINER_multihashmap_remove (plugin->nat_wait_conns,
+                                                       &tcp_nat_probe->clientIdentity.hashPubKey,
+                                                       session) == GNUNET_YES);
+  if (GNUNET_OK != GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
+  {
+    GNUNET_break (0);
+    GNUNET_free (session);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
 
   GNUNET_SERVER_client_keep (client);
   session->client = client;
@@ -1581,51 +1515,47 @@ handle_tcp_nat_probe (void *cls,
 
 #if DEBUG_TCP_NAT
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
-                   "Found address `%s' for incoming connection\n",
-                   GNUNET_a2s (vaddr, alen));
+                   "tcp",
+                   "Found address `%s' for incoming connection\n",
+                   GNUNET_a2s (vaddr, alen));
 #endif
-  switch (((const struct sockaddr *)vaddr)->sa_family)
-    {
-    case AF_INET:
-      s4 = vaddr;
-      t4 = GNUNET_malloc (sizeof (struct IPv4TcpAddress));
-      t4->t4_port = s4->sin_port;
-      t4->ipv4_addr = s4->sin_addr.s_addr;
-      session->connect_addr = t4;
-      session->connect_alen = sizeof (struct IPv4TcpAddress);
-      break;
-    case AF_INET6:    
-      s6 = vaddr;
-      t6 = GNUNET_malloc (sizeof (struct IPv6TcpAddress));
-      t6->t6_port = s6->sin6_port;
-      memcpy (&t6->ipv6_addr,
-              &s6->sin6_addr,
-              sizeof (struct in6_addr));
-      session->connect_addr = t6;
-      session->connect_alen = sizeof (struct IPv6TcpAddress);
-      break;
-    default:
-      GNUNET_break_op (0);
+  switch (((const struct sockaddr *) vaddr)->sa_family)
+  {
+  case AF_INET:
+    s4 = vaddr;
+    t4 = GNUNET_malloc (sizeof (struct IPv4TcpAddress));
+    t4->t4_port = s4->sin_port;
+    t4->ipv4_addr = s4->sin_addr.s_addr;
+    session->connect_addr = t4;
+    session->connect_alen = sizeof (struct IPv4TcpAddress);
+    break;
+  case AF_INET6:
+    s6 = vaddr;
+    t6 = GNUNET_malloc (sizeof (struct IPv6TcpAddress));
+    t6->t6_port = s6->sin6_port;
+    memcpy (&t6->ipv6_addr, &s6->sin6_addr, sizeof (struct in6_addr));
+    session->connect_addr = t6;
+    session->connect_alen = sizeof (struct IPv6TcpAddress);
+    break;
+  default:
+    GNUNET_break_op (0);
 #if DEBUG_TCP_NAT
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       "Bad address for incoming connection!\n");
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp", "Bad address for incoming connection!\n");
 #endif
-      GNUNET_free (vaddr);
-      GNUNET_SERVER_client_drop (client);
-      GNUNET_free (session);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+    GNUNET_free (vaddr);
+    GNUNET_SERVER_client_drop (client);
+    GNUNET_free (session);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   GNUNET_free (vaddr);
-  
+
   session->next = plugin->sessions;
   plugin->sessions = session;
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# TCP sessions active"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# TCP sessions active"),
+                            1, GNUNET_NO);
   process_pending_messages (session);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
@@ -1653,109 +1583,100 @@ handle_tcp_welcome (void *cls,
   struct IPv6TcpAddress *t6;
   const struct sockaddr_in *s4;
   const struct sockaddr_in6 *s6;
-  
+
   if (0 == memcmp (&wm->clientIdentity,
-                   plugin->env->my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      /* refuse connections from ourselves */
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+                   plugin->env->my_identity,
+                   sizeof (struct GNUNET_PeerIdentity)))
+  {
+    /* refuse connections from ourselves */
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
 #if DEBUG_TCP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
+                   "tcp",
                    "Received %s message from `%4s'.\n",
-                   "WELCOME",
-                   GNUNET_i2s (&wm->clientIdentity));
+                   "WELCOME", GNUNET_i2s (&wm->clientIdentity));
 #endif
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# TCP WELCOME messages received"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# TCP WELCOME messages received"),
+                            1, GNUNET_NO);
   session = find_session_by_client (plugin, client);
 
   if (session == NULL)
-    {
+  {
 #if DEBUG_TCP_NAT
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       "Received %s message from a `%4s', creating new session\n",
-                       "WELCOME",
-                       GNUNET_i2s (&wm->clientIdentity));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp",
+                     "Received %s message from a `%4s', creating new session\n",
+                     "WELCOME", GNUNET_i2s (&wm->clientIdentity));
 #endif
-      GNUNET_SERVER_client_keep (client);
-      session = create_session (plugin,
-                                &wm->clientIdentity,
-                                client,
-                                GNUNET_NO);
-      session->inbound = GNUNET_YES;
-      if (GNUNET_OK ==
-          GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
-        {
+    GNUNET_SERVER_client_keep (client);
+    session = create_session (plugin, &wm->clientIdentity, client, GNUNET_NO);
+    session->inbound = GNUNET_YES;
+    if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
+    {
 #if DEBUG_TCP_NAT
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                           "tcp",
-                           "Found address `%s' for incoming connection\n",
-                           GNUNET_a2s (vaddr, alen));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "tcp",
+                       "Found address `%s' for incoming connection\n",
+                       GNUNET_a2s (vaddr, alen));
 #endif
-          if (alen == sizeof (struct sockaddr_in))
-            {
-              s4 = vaddr;
-              t4 = GNUNET_malloc (sizeof (struct IPv4TcpAddress));
-              t4->t4_port = s4->sin_port;
-              t4->ipv4_addr = s4->sin_addr.s_addr;
-              session->connect_addr = t4;
-              session->connect_alen = sizeof (struct IPv4TcpAddress);
-            }
-          else if (alen == sizeof (struct sockaddr_in6))
-            {
-              s6 = vaddr;
-              t6 = GNUNET_malloc (sizeof (struct IPv6TcpAddress));
-              t6->t6_port = s6->sin6_port;
-              memcpy (&t6->ipv6_addr,
-                      &s6->sin6_addr,
-                      sizeof (struct in6_addr));
-              session->connect_addr = t6;
-              session->connect_alen = sizeof (struct IPv6TcpAddress);
-            }
-
-          GNUNET_free (vaddr);
-        }
-      else
-        {
+      if (alen == sizeof (struct sockaddr_in))
+      {
+        s4 = vaddr;
+        t4 = GNUNET_malloc (sizeof (struct IPv4TcpAddress));
+        t4->t4_port = s4->sin_port;
+        t4->ipv4_addr = s4->sin_addr.s_addr;
+        session->connect_addr = t4;
+        session->connect_alen = sizeof (struct IPv4TcpAddress);
+      }
+      else if (alen == sizeof (struct sockaddr_in6))
+      {
+        s6 = vaddr;
+        t6 = GNUNET_malloc (sizeof (struct IPv6TcpAddress));
+        t6->t6_port = s6->sin6_port;
+        memcpy (&t6->ipv6_addr, &s6->sin6_addr, sizeof (struct in6_addr));
+        session->connect_addr = t6;
+        session->connect_alen = sizeof (struct IPv6TcpAddress);
+      }
+
+      GNUNET_free (vaddr);
+    }
+    else
+    {
 #if DEBUG_TCP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                           "tcp",
-                           "Did not obtain TCP socket address for incoming connection\n");
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "tcp",
+                       "Did not obtain TCP socket address for incoming connection\n");
 #endif
-        }
-      process_pending_messages (session);
     }
+    process_pending_messages (session);
+  }
   else
-    {
+  {
 #if DEBUG_TCP_NAT
-    if (GNUNET_OK ==
-        GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
-      {
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                         "tcp",
-                         "Found address `%s' (already have session)\n",
-                         GNUNET_a2s (vaddr, alen));
-        GNUNET_free (vaddr);
-      }
-#endif
+    if (GNUNET_OK == GNUNET_SERVER_client_get_address (client, &vaddr, &alen))
+    {
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "tcp",
+                       "Found address `%s' (already have session)\n",
+                       GNUNET_a2s (vaddr, alen));
+      GNUNET_free (vaddr);
     }
+#endif
+  }
 
   if (session->expecting_welcome != GNUNET_YES)
-    {
-      GNUNET_break_op (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   session->last_activity = GNUNET_TIME_absolute_get ();
   session->expecting_welcome = GNUNET_NO;
-  GNUNET_SERVER_client_set_timeout(client, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  GNUNET_SERVER_client_set_timeout (client,
+                                    GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -1768,24 +1689,20 @@ handle_tcp_welcome (void *cls,
  * @param tc task context (unused)
  */
 static void
-delayed_done (void *cls, 
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+delayed_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Session *session = cls;
   struct GNUNET_TIME_Relative delay;
 
   session->receive_delay_task = GNUNET_SCHEDULER_NO_TASK;
   delay = session->plugin->env->receive (session->plugin->env->cls,
-                                         &session->target,
-                                         NULL,
-                                         NULL, 0,
-                                         session,
-                                         NULL, 0);
+                                         &session->target,
+                                         NULL, NULL, 0, session, NULL, 0);
   if (delay.rel_value == 0)
     GNUNET_SERVER_receive_done (session->client, GNUNET_OK);
   else
     session->receive_delay_task =
-      GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
+        GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
 }
 
 
@@ -1808,60 +1725,62 @@ handle_tcp_data (void *cls,
   uint16_t type;
 
   type = ntohs (message->type);
-  if ( (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME == type) || 
-       (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE == type) )
-    {
-      /* We don't want to propagate WELCOME and NAT Probe messages up! */
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+  if ((GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME == type) ||
+      (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE == type))
+  {
+    /* We don't want to propagate WELCOME and NAT Probe messages up! */
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   session = find_session_by_client (plugin, client);
-  if ( (NULL == session) || (GNUNET_YES == session->expecting_welcome) )
-    {
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  if ((NULL == session) || (GNUNET_YES == session->expecting_welcome))
+  {
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   session->last_activity = GNUNET_TIME_absolute_get ();
 #if DEBUG_TCP > 1
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
-                   "Passing %u bytes of type %u from `%4s' to transport service.\n",
+                   "tcp",
+                   "Passing %u bytes of type %u from `%4s' to transport service.\n",
                    (unsigned int) ntohs (message->size),
-                   (unsigned int) ntohs (message->type),
-                   GNUNET_i2s (&session->target));
+                   (unsigned int) ntohs (message->type),
+                   GNUNET_i2s (&session->target));
 #endif
   GNUNET_STATISTICS_update (plugin->env->stats,
-                            gettext_noop ("# bytes received via TCP"),
-                            ntohs (message->size),
-                            GNUNET_NO);
+                            gettext_noop ("# bytes received via TCP"),
+                            ntohs (message->size), GNUNET_NO);
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
+
   distance[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
   distance[0].value = htonl (1);
   distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   distance[1].value = htonl (0);
   delay = plugin->env->receive (plugin->env->cls, &session->target, message,
-                                (const struct GNUNET_TRANSPORT_ATS_Information *) &distance,
-                                2,
-                                session,
-                                (GNUNET_YES == session->inbound) ? NULL : session->connect_addr,
-                                (GNUNET_YES == session->inbound) ? 0 : session->connect_alen);
+                                (const struct GNUNET_TRANSPORT_ATS_Information
+                                 *) &distance, 2, session,
+                                (GNUNET_YES ==
+                                 session->
+                                 inbound) ? NULL : session->connect_addr,
+                                (GNUNET_YES ==
+                                 session->inbound) ? 0 : session->connect_alen);
   if (delay.rel_value == 0)
-    {
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-    }
+  {
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  }
   else
-    {
-#if DEBUG_TCP 
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "tcp",
-                       "Throttling receiving from `%s' for %llu ms\n",
-                       GNUNET_i2s (&session->target),
-                       (unsigned long long) delay.rel_value);
+  {
+#if DEBUG_TCP
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "tcp",
+                     "Throttling receiving from `%s' for %llu ms\n",
+                     GNUNET_i2s (&session->target),
+                     (unsigned long long) delay.rel_value);
 #endif
-      GNUNET_SERVER_disable_receive_done_warning (client);
-      session->receive_delay_task =
-        GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
-    }
+    GNUNET_SERVER_disable_receive_done_warning (client);
+    session->receive_delay_task =
+        GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
+  }
 }
 
 
@@ -1873,8 +1792,7 @@ handle_tcp_data (void *cls,
  * @param client identification of the client
  */
 static void
-disconnect_notify (void *cls,
-                   struct GNUNET_SERVER_Client *client)
+disconnect_notify (void *cls, struct GNUNET_SERVER_Client *client)
 {
   struct Plugin *plugin = cls;
   struct Session *session;
@@ -1887,18 +1805,18 @@ disconnect_notify (void *cls,
     return;                     /* unknown, nothing to do */
 #if DEBUG_TCP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "tcp",
+                   "tcp",
                    "Destroying session of `%4s' with %s due to network-level disconnect.\n",
                    GNUNET_i2s (&session->target),
                    (session->connect_addr != NULL) ?
                    tcp_address_to_string (session->plugin,
-                                          session->connect_addr,
-                                          session->connect_alen) : "*");
+                                          session->connect_addr,
+                                          session->connect_alen) : "*");
 #endif
   GNUNET_STATISTICS_update (session->plugin->env->stats,
-                            gettext_noop ("# network-level TCP disconnect events"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# network-level TCP disconnect events"), 1,
+                            GNUNET_NO);
   disconnect_session (session);
 }
 
@@ -1912,9 +1830,7 @@ disconnect_notify (void *cls,
  * @return number of bytes copied into buf
  */
 static size_t
-notify_send_probe (void *cls,
-                   size_t size,
-                   void *buf)
+notify_send_probe (void *cls, size_t size, void *buf)
 {
   struct TCPProbeContext *tcp_probe_ctx = cls;
   struct Plugin *plugin = tcp_probe_ctx->plugin;
@@ -1922,20 +1838,19 @@ notify_send_probe (void *cls,
 
   tcp_probe_ctx->transmit_handle = NULL;
   GNUNET_CONTAINER_DLL_remove (plugin->probe_head,
-                               plugin->probe_tail,
-                               tcp_probe_ctx);
+                               plugin->probe_tail, tcp_probe_ctx);
   if (buf == NULL)
-    {
-      GNUNET_CONNECTION_destroy (tcp_probe_ctx->sock, GNUNET_NO);
-      GNUNET_free(tcp_probe_ctx);
-      return 0;    
-    }
-  GNUNET_assert(size >= sizeof(tcp_probe_ctx->message));
-  memcpy(buf, &tcp_probe_ctx->message, sizeof(tcp_probe_ctx->message));
+  {
+    GNUNET_CONNECTION_destroy (tcp_probe_ctx->sock, GNUNET_NO);
+    GNUNET_free (tcp_probe_ctx);
+    return 0;
+  }
+  GNUNET_assert (size >= sizeof (tcp_probe_ctx->message));
+  memcpy (buf, &tcp_probe_ctx->message, sizeof (tcp_probe_ctx->message));
   GNUNET_SERVER_connect_socket (tcp_probe_ctx->plugin->server,
                                 tcp_probe_ctx->sock);
-  ret = sizeof(tcp_probe_ctx->message);
-  GNUNET_free(tcp_probe_ctx);
+  ret = sizeof (tcp_probe_ctx->message);
+  GNUNET_free (tcp_probe_ctx);
   return ret;
 }
 
@@ -1951,8 +1866,7 @@ notify_send_probe (void *cls,
  */
 static void
 try_connection_reversal (void *cls,
-                         const struct sockaddr *addr,
-                         socklen_t addrlen)
+                         const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct GNUNET_CONNECTION_Handle *sock;
@@ -1962,37 +1876,34 @@ try_connection_reversal (void *cls,
    * We have received an ICMP response, ostensibly from a peer
    * that wants to connect to us! Send a message to establish a connection.
    */
-  sock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, 
-                                                 addr,
-                                                 addrlen);
+  sock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, addr, addrlen);
   if (sock == NULL)
-    {
-      /* failed for some odd reason (out of sockets?); ignore attempt */
-      return;
-    }
+  {
+    /* failed for some odd reason (out of sockets?); ignore attempt */
+    return;
+  }
 
   /* FIXME: do we need to track these probe context objects so that
-     we can clean them up on plugin unload? */
-  tcp_probe_ctx
-    = GNUNET_malloc(sizeof(struct TCPProbeContext));
+   * we can clean them up on plugin unload? */
+  tcp_probe_ctx = GNUNET_malloc (sizeof (struct TCPProbeContext));
   tcp_probe_ctx->message.header.size
-    = htons(sizeof(struct TCP_NAT_ProbeMessage));
+      = htons (sizeof (struct TCP_NAT_ProbeMessage));
   tcp_probe_ctx->message.header.type
-    = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE);
+      = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE);
   memcpy (&tcp_probe_ctx->message.clientIdentity,
-          plugin->env->my_identity,
-          sizeof(struct GNUNET_PeerIdentity));
+          plugin->env->my_identity, sizeof (struct GNUNET_PeerIdentity));
   tcp_probe_ctx->plugin = plugin;
   tcp_probe_ctx->sock = sock;
   GNUNET_CONTAINER_DLL_insert (plugin->probe_head,
-                               plugin->probe_tail,
-                               tcp_probe_ctx);
-  tcp_probe_ctx->transmit_handle 
-    = GNUNET_CONNECTION_notify_transmit_ready (sock,
-                                               ntohs (tcp_probe_ctx->message.header.size),
-                                               GNUNET_TIME_UNIT_FOREVER_REL,
-                                               &notify_send_probe, tcp_probe_ctx);
-  
+                               plugin->probe_tail, tcp_probe_ctx);
+  tcp_probe_ctx->transmit_handle
+      = GNUNET_CONNECTION_notify_transmit_ready (sock,
+                                                 ntohs (tcp_probe_ctx->
+                                                        message.header.size),
+                                                 GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 &notify_send_probe,
+                                                 tcp_probe_ctx);
+
 }
 
 
@@ -2008,7 +1919,8 @@ libgnunet_plugin_transport_tcp_init (void *cls)
   static const struct GNUNET_SERVER_MessageHandler my_handlers[] = {
     {&handle_tcp_welcome, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME,
      sizeof (struct WelcomeMessage)},
-    {&handle_tcp_nat_probe, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE, sizeof (struct TCP_NAT_ProbeMessage)},
+    {&handle_tcp_nat_probe, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE,
+     sizeof (struct TCP_NAT_ProbeMessage)},
     {&handle_tcp_data, NULL, GNUNET_MESSAGE_TYPE_ALL, 0},
     {NULL, NULL, 0, 0}
   };
@@ -2031,42 +1943,41 @@ libgnunet_plugin_transport_tcp_init (void *cls)
                                              "MAX_CONNECTIONS",
                                              &max_connections))
     max_connections = 128;
-  
+
   aport = 0;
-  if ( (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                               "transport-tcp",
-                                               "PORT",
-                                               &bport)) ||
-       (bport > 65535) ||
-       ((GNUNET_OK ==
-         GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                                "transport-tcp",
-                                                "ADVERTISED-PORT",
-                                                &aport)) && 
-        (aport > 65535)) )
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "tcp",
-                       _("Require valid port number for service `%s' in configuration!\n"),
-                       "transport-tcp");
-      return NULL;
-    } 
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_number (env->cfg,
+                                              "transport-tcp",
+                                              "PORT",
+                                              &bport)) ||
+      (bport > 65535) ||
+      ((GNUNET_OK ==
+        GNUNET_CONFIGURATION_get_value_number (env->cfg,
+                                               "transport-tcp",
+                                               "ADVERTISED-PORT",
+                                               &aport)) && (aport > 65535)))
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "tcp",
+                     _
+                     ("Require valid port number for service `%s' in configuration!\n"),
+                     "transport-tcp");
+    return NULL;
+  }
   if (aport == 0)
     aport = bport;
   if (bport == 0)
     aport = 0;
   if (bport != 0)
+  {
+    service = GNUNET_SERVICE_start ("transport-tcp", env->cfg);
+    if (service == NULL)
     {
-      service = GNUNET_SERVICE_start ("transport-tcp", env->cfg);      
-      if (service == NULL)
-        {
-          GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                           "tcp",
-                           _("Failed to start service.\n"));
-          return NULL;
-        }
+      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                       "tcp", _("Failed to start service.\n"));
+      return NULL;
     }
+  }
   else
     service = NULL;
 
@@ -2078,41 +1989,37 @@ libgnunet_plugin_transport_tcp_init (void *cls)
   plugin->adv_port = aport;
   plugin->env = env;
   plugin->lsock = NULL;
-  if ( (service != NULL) &&
-       (GNUNET_SYSERR !=
-        (ret = GNUNET_SERVICE_get_server_addresses ("transport-tcp",
-                                                    env->cfg,
-                                                    &addrs,
-                                                    &addrlens))) )
+  if ((service != NULL) &&
+      (GNUNET_SYSERR !=
+       (ret = GNUNET_SERVICE_get_server_addresses ("transport-tcp",
+                                                   env->cfg,
+                                                   &addrs, &addrlens))))
+  {
+    plugin->nat = GNUNET_NAT_register (env->cfg,
+                                       GNUNET_YES,
+                                       aport,
+                                       (unsigned int) ret,
+                                       (const struct sockaddr **) addrs,
+                                       addrlens,
+                                       &tcp_nat_port_map_callback,
+                                       &try_connection_reversal, plugin);
+    while (ret > 0)
     {
-      plugin->nat = GNUNET_NAT_register (env->cfg,
-                                         GNUNET_YES,
-                                         aport,
-                                         (unsigned int) ret,
-                                         (const struct sockaddr **) addrs,
-                                         addrlens,
-                                         &tcp_nat_port_map_callback,
-                                         &try_connection_reversal,
-                                         plugin);
-      while (ret > 0)
-      {
-        ret--;
-        GNUNET_assert (addrs[ret] != NULL);
-        GNUNET_free (addrs[ret]);
-      }
-      GNUNET_free_non_null (addrs);
-      GNUNET_free_non_null (addrlens);
+      ret--;
+      GNUNET_assert (addrs[ret] != NULL);
+      GNUNET_free (addrs[ret]);
     }
+    GNUNET_free_non_null (addrs);
+    GNUNET_free_non_null (addrlens);
+  }
   else
-    {
-      plugin->nat = GNUNET_NAT_register (env->cfg,
-                                         GNUNET_YES,
-                                         0,
-                                         0, NULL, NULL,
-                                         NULL,
-                                         &try_connection_reversal,
-                                         plugin);
-    }
+  {
+    plugin->nat = GNUNET_NAT_register (env->cfg,
+                                       GNUNET_YES,
+                                       0,
+                                       0, NULL, NULL,
+                                       NULL, &try_connection_reversal, plugin);
+  }
   api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
   api->cls = plugin;
   api->send = &tcp_plugin_send;
@@ -2121,32 +2028,31 @@ libgnunet_plugin_transport_tcp_init (void *cls)
   api->check_address = &tcp_plugin_check_address;
   api->address_to_string = &tcp_address_to_string;
   plugin->service = service;
-  if (service != NULL)   
-    {
-      plugin->server = GNUNET_SERVICE_get_server (service);
-    }
+  if (service != NULL)
+  {
+    plugin->server = GNUNET_SERVICE_get_server (service);
+  }
   else
+  {
+    if (GNUNET_OK !=
+        GNUNET_CONFIGURATION_get_value_time (env->cfg,
+                                             "transport-tcp",
+                                             "TIMEOUT", &idle_timeout))
     {
-      if (GNUNET_OK !=
-          GNUNET_CONFIGURATION_get_value_time (env->cfg,
-                                               "transport-tcp",
-                                               "TIMEOUT",
-                                               &idle_timeout))
-        {
-          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                           "tcp",
-                           _("Failed to find option %s in section %s!\n"),
-                           "TIMEOUT",
-                           "transport-tcp");
-          if (plugin->nat != NULL)
-            GNUNET_NAT_unregister (plugin->nat);
-          GNUNET_free (plugin);
-          GNUNET_free (api);
-          return NULL;
-        }
-      plugin->server = GNUNET_SERVER_create_with_sockets (&plugin_tcp_access_check, plugin, NULL,
-                                                          idle_timeout, GNUNET_YES);
+      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                       "tcp",
+                       _("Failed to find option %s in section %s!\n"),
+                       "TIMEOUT", "transport-tcp");
+      if (plugin->nat != NULL)
+        GNUNET_NAT_unregister (plugin->nat);
+      GNUNET_free (plugin);
+      GNUNET_free (api);
+      return NULL;
     }
+    plugin->server =
+        GNUNET_SERVER_create_with_sockets (&plugin_tcp_access_check, plugin,
+                                           NULL, idle_timeout, GNUNET_YES);
+  }
   plugin->handlers = GNUNET_malloc (sizeof (my_handlers));
   memcpy (plugin->handlers, my_handlers, sizeof (my_handlers));
   for (i = 0;
@@ -2154,23 +2060,21 @@ libgnunet_plugin_transport_tcp_init (void *cls)
        i++)
     plugin->handlers[i].callback_cls = plugin;
   GNUNET_SERVER_add_handlers (plugin->server, plugin->handlers);
-  GNUNET_SERVER_disconnect_notify (plugin->server,
-                                   &disconnect_notify,
-                                   plugin);    
-  plugin->nat_wait_conns = GNUNET_CONTAINER_multihashmap_create(16);
+  GNUNET_SERVER_disconnect_notify (plugin->server, &disconnect_notify, plugin);
+  plugin->nat_wait_conns = GNUNET_CONTAINER_multihashmap_create (16);
   if (bport != 0)
-    GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, 
-                     "tcp",
-                     _("TCP transport listening on port %llu\n"), 
-                     bport);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
+                     "tcp", _("TCP transport listening on port %llu\n"), bport);
   else
-    GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, 
-                     "tcp",
-                     _("TCP transport not listening on any port (client only)\n"));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
+                     "tcp",
+                     _
+                     ("TCP transport not listening on any port (client only)\n"));
   if (aport != bport)
     GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
-                     "tcp",
-                     _("TCP transport advertises itself as being on port %llu\n"),
+                     "tcp",
+                     _
+                     ("TCP transport advertises itself as being on port %llu\n"),
                      aport);
   return api;
 }
@@ -2197,13 +2101,12 @@ libgnunet_plugin_transport_tcp_done (void *cls)
   if (plugin->nat != NULL)
     GNUNET_NAT_unregister (plugin->nat);
   while (NULL != (tcp_probe = plugin->probe_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (plugin->probe_head,
-                                   plugin->probe_tail,
-                                   tcp_probe);
-      GNUNET_CONNECTION_destroy (tcp_probe->sock, GNUNET_NO);
-      GNUNET_free (tcp_probe);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (plugin->probe_head,
+                                 plugin->probe_tail, tcp_probe);
+    GNUNET_CONNECTION_destroy (tcp_probe->sock, GNUNET_NO);
+    GNUNET_free (tcp_probe);
+  }
   GNUNET_CONTAINER_multihashmap_destroy (plugin->nat_wait_conns);
   GNUNET_free (plugin);
   GNUNET_free (api);
diff --git a/src/transport/plugin_transport_template.c b/src/transport/plugin_transport_template.c
index fb0421ee3..d83807a36 100644
--- a/src/transport/plugin_transport_template.c
+++ b/src/transport/plugin_transport_template.c
@@ -152,13 +152,12 @@ struct Plugin
  */
 static ssize_t
 template_plugin_send (void *cls,
-                      const struct GNUNET_PeerIdentity *
-                      target,
+                      const struct GNUNET_PeerIdentity *target,
                       const char *msgbuf,
                       size_t msgbuf_size,
                       unsigned int priority,
                       struct GNUNET_TIME_Relative timeout,
-                      struct Session *session,
+                      struct Session *session,
                       const void *addr,
                       size_t addrlen,
                       int force_address,
@@ -166,6 +165,7 @@ template_plugin_send (void *cls,
                       cont, void *cont_cls)
 {
   int bytes_sent = 0;
+
   /*  struct Plugin *plugin = cls; */
   return bytes_sent;
 }
@@ -181,8 +181,7 @@ template_plugin_send (void *cls,
  * @param target peer from which to disconnect
  */
 static void
-template_plugin_disconnect (void *cls,
-                            const struct GNUNET_PeerIdentity *target)
+template_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
 {
   // struct Plugin *plugin = cls;
   // FIXME
@@ -231,14 +230,12 @@ template_plugin_address_pretty_printer (void *cls,
  *         and transport
  */
 static int
-template_plugin_address_suggested (void *cls,
-                                   const void *addr,
-                                   size_t addrlen)
+template_plugin_address_suggested (void *cls, const void *addr, size_t addrlen)
 {
   /* struct Plugin *plugin = cls; */
 
   /* check if the address is plausible; if so,
-     add it to our list! */
+   * add it to our list! */
   return GNUNET_OK;
 }
 
@@ -254,10 +251,8 @@ template_plugin_address_suggested (void *cls,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-template_plugin_address_to_string (void *cls,
-                                   const void *addr,
-                                   size_t addrlen)
+static const char *
+template_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   GNUNET_break (0);
   return NULL;
diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c
index 7d8c1520f..df8447a12 100644
--- a/src/transport/plugin_transport_udp.c
+++ b/src/transport/plugin_transport_udp.c
@@ -193,7 +193,7 @@ struct ReceiveContext
 
   /**
    * Node in the defrag heap.
-   */ 
+   */
   struct GNUNET_CONTAINER_HeapNode *hnode;
 
   /**
@@ -297,11 +297,10 @@ struct Plugin
  * @return NULL if we have no session
  */
 struct PeerSession *
-find_session (struct Plugin *plugin,
-              const struct GNUNET_PeerIdentity *peer)
+find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CONTAINER_multihashmap_get (plugin->sessions, 
-                                            &peer->hashPubKey);
+  return GNUNET_CONTAINER_multihashmap_get (plugin->sessions,
+                                            &peer->hashPubKey);
 }
 
 
@@ -322,9 +321,9 @@ udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
   if (NULL == session)
     return;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
-                                                       &target->hashPubKey,
-                                                       session));
+                 GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
+                                                       &target->hashPubKey,
+                                                       session));
   plugin->last_expected_delay = GNUNET_FRAGMENT_context_destroy (session->frag);
   session->cont (session->cont_cls, target, GNUNET_SYSERR);
   GNUNET_free (session);
@@ -352,48 +351,43 @@ udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
  */
 static ssize_t
 udp_send (struct Plugin *plugin,
-          const struct sockaddr *sa,
-          const struct GNUNET_MessageHeader *msg)
+          const struct sockaddr *sa, const struct GNUNET_MessageHeader *msg)
 {
   ssize_t sent;
   size_t slen;
 
   switch (sa->sa_family)
-    {
-    case AF_INET:
-      if (NULL == plugin->sockv4)
-        return 0;
-      sent =
-        GNUNET_NETWORK_socket_sendto (plugin->sockv4,
-                                      msg,
-                                      ntohs (msg->size),
-                                      sa,
-                                      slen = sizeof (struct sockaddr_in));
-      break;
-    case AF_INET6:
-      if (NULL == plugin->sockv6)
-        return 0;
-      sent =
-        GNUNET_NETWORK_socket_sendto (plugin->sockv6,
-                                      msg,
-                                      ntohs (msg->size),
-                                      sa,
-                                      slen = sizeof (struct sockaddr_in6));
-      break;
-    default:
-      GNUNET_break (0);
+  {
+  case AF_INET:
+    if (NULL == plugin->sockv4)
       return 0;
-    }
+    sent =
+        GNUNET_NETWORK_socket_sendto (plugin->sockv4,
+                                      msg,
+                                      ntohs (msg->size),
+                                      sa, slen = sizeof (struct sockaddr_in));
+    break;
+  case AF_INET6:
+    if (NULL == plugin->sockv6)
+      return 0;
+    sent =
+        GNUNET_NETWORK_socket_sendto (plugin->sockv6,
+                                      msg,
+                                      ntohs (msg->size),
+                                      sa, slen = sizeof (struct sockaddr_in6));
+    break;
+  default:
+    GNUNET_break (0);
+    return 0;
+  }
   if (GNUNET_SYSERR == sent)
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, 
-                         "sendto");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "sendto");
 #if DEBUG_UDP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "UDP transmited %u-byte message to %s (%d: %s)\n",
-              (unsigned int) ntohs (msg->size),
-              GNUNET_a2s (sa, slen),
-              (int) sent,
-              (sent < 0) ? STRERROR (errno) : "ok");
+              "UDP transmited %u-byte message to %s (%d: %s)\n",
+              (unsigned int) ntohs (msg->size),
+              GNUNET_a2s (sa, slen),
+              (int) sent, (sent < 0) ? STRERROR (errno) : "ok");
 #endif
   return sent;
 }
@@ -408,15 +402,12 @@ udp_send (struct Plugin *plugin,
  * @param cls closure, the 'struct PeerSession'
  * @param msg the message that was created
  */
-static void 
-send_fragment (void *cls,
-               const struct GNUNET_MessageHeader *msg)
+static void
+send_fragment (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct PeerSession *session = cls;
 
-  udp_send (session->plugin,
-            session->sock_addr,
-            msg);
+  udp_send (session->plugin, session->sock_addr, msg);
   GNUNET_FRAGMENT_context_transmission_done (session->frag);
 }
 
@@ -447,16 +438,16 @@ send_fragment (void *cls,
  */
 static ssize_t
 udp_plugin_send (void *cls,
-                 const struct GNUNET_PeerIdentity *target,
-                 const char *msgbuf,
-                 size_t msgbuf_size,
-                 unsigned int priority,
-                 struct GNUNET_TIME_Relative timeout,
-                 struct Session *session,
-                 const void *addr,
-                 size_t addrlen,
-                 int force_address,
-                 GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
+                 const struct GNUNET_PeerIdentity *target,
+                 const char *msgbuf,
+                 size_t msgbuf_size,
+                 unsigned int priority,
+                 struct GNUNET_TIME_Relative timeout,
+                 struct Session *session,
+                 const void *addr,
+                 size_t addrlen,
+                 int force_address,
+                 GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
   struct Plugin *plugin = cls;
   struct PeerSession *peer_session;
@@ -472,50 +463,54 @@ udp_plugin_send (void *cls,
     return GNUNET_SYSERR;
   GNUNET_assert (NULL == session);
   if (mlen >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   switch (addrlen)
+  {
+  case sizeof (struct IPv4UdpAddress):
+    if (NULL == plugin->sockv4)
     {
-    case sizeof(struct IPv4UdpAddress):   
-      if (NULL == plugin->sockv4)
-        {
-          cont (cont_cls, target, GNUNET_SYSERR);
-          return 0;
-        }
-      t4 = addr;
-      peer_session = GNUNET_malloc (sizeof (struct PeerSession) + sizeof (struct sockaddr_in));
-      v4 = (struct sockaddr_in*) &peer_session[1];
-      v4->sin_family = AF_INET;
+      cont (cont_cls, target, GNUNET_SYSERR);
+      return 0;
+    }
+    t4 = addr;
+    peer_session =
+        GNUNET_malloc (sizeof (struct PeerSession) +
+                       sizeof (struct sockaddr_in));
+    v4 = (struct sockaddr_in *) &peer_session[1];
+    v4->sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      v4->sin_len = sizeof (struct sockaddr_in);
+    v4->sin_len = sizeof (struct sockaddr_in);
 #endif
-      v4->sin_port = t4->u4_port;
-      v4->sin_addr.s_addr = t4->ipv4_addr;
-      break;
-    case sizeof(struct IPv6UdpAddress):
-      if (NULL == plugin->sockv6)
-        {
-          cont (cont_cls, target, GNUNET_SYSERR);
-          return 0;
-        }
-      t6 = addr;
-      peer_session = GNUNET_malloc (sizeof (struct PeerSession) + sizeof (struct sockaddr_in6));
-      v6 = (struct sockaddr_in6*) &peer_session[1];
-      v6->sin6_family = AF_INET6;
+    v4->sin_port = t4->u4_port;
+    v4->sin_addr.s_addr = t4->ipv4_addr;
+    break;
+  case sizeof (struct IPv6UdpAddress):
+    if (NULL == plugin->sockv6)
+    {
+      cont (cont_cls, target, GNUNET_SYSERR);
+      return 0;
+    }
+    t6 = addr;
+    peer_session =
+        GNUNET_malloc (sizeof (struct PeerSession) +
+                       sizeof (struct sockaddr_in6));
+    v6 = (struct sockaddr_in6 *) &peer_session[1];
+    v6->sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      v6->sin6_len = sizeof (struct sockaddr_in6);
+    v6->sin6_len = sizeof (struct sockaddr_in6);
 #endif
-      v6->sin6_port = t6->u6_port;
-      v6->sin6_addr = t6->ipv6_addr;
-      break;
-    default:
-      /* Must have a valid address to send to */
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  udp = (struct UDPMessage*) mbuf;
+    v6->sin6_port = t6->u6_port;
+    v6->sin6_addr = t6->ipv6_addr;
+    break;
+  default:
+    /* Must have a valid address to send to */
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  udp = (struct UDPMessage *) mbuf;
   udp->header.size = htons (mlen);
   udp->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE);
   udp->reserved = htonl (0);
@@ -523,32 +518,30 @@ udp_plugin_send (void *cls,
   memcpy (&udp[1], msgbuf, msgbuf_size);
   peer_session->target = *target;
   peer_session->plugin = plugin;
-  peer_session->sock_addr = (const struct sockaddr*) &peer_session[1];
+  peer_session->sock_addr = (const struct sockaddr *) &peer_session[1];
   peer_session->cont = cont;
-  peer_session->cont_cls = cont_cls;  
+  peer_session->cont_cls = cont_cls;
   if (mlen <= UDP_MTU)
-    {
-      mlen = udp_send (plugin, 
-                       peer_session->sock_addr,
-                       &udp->header);
-      cont (cont_cls, target, (mlen > 0) ? GNUNET_OK : GNUNET_SYSERR);
-      GNUNET_free (peer_session);      
-    }
+  {
+    mlen = udp_send (plugin, peer_session->sock_addr, &udp->header);
+    cont (cont_cls, target, (mlen > 0) ? GNUNET_OK : GNUNET_SYSERR);
+    GNUNET_free (peer_session);
+  }
   else
-    {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (plugin->sessions,
-                                                        &target->hashPubKey,
-                                                        peer_session,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      peer_session->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
-                                                           UDP_MTU,
-                                                           &plugin->tracker,
-                                                           plugin->last_expected_delay,
-                                                           &udp->header,
-                                                           &send_fragment,
-                                                           peer_session);
-    }
+  {
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (plugin->sessions,
+                                                      &target->hashPubKey,
+                                                      peer_session,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    peer_session->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
+                                                         UDP_MTU,
+                                                         &plugin->tracker,
+                                                         plugin->last_expected_delay,
+                                                         &udp->header,
+                                                         &send_fragment,
+                                                         peer_session);
+  }
   return mlen;
 }
 
@@ -562,7 +555,7 @@ struct SourceInformation
    * Sender identity.
    */
   struct GNUNET_PeerIdentity sender;
-  
+
   /**
    * Source address.
    */
@@ -585,11 +578,11 @@ struct SourceInformation
  */
 static void
 process_inbound_tokenized_messages (void *cls,
-                                    void *client,
-                                    const struct GNUNET_MessageHeader *hdr)
+                                    void *client,
+                                    const struct GNUNET_MessageHeader *hdr)
 {
   struct Plugin *plugin = cls;
-  struct SourceInformation* si = client;
+  struct SourceInformation *si = client;
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
 
   /* setup ATS */
@@ -598,12 +591,8 @@ process_inbound_tokenized_messages (void *cls,
   distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   distance[1].value = htonl (0);
 
-  plugin->env->receive (plugin->env->cls, 
-                        &si->sender, 
-                        hdr,
-                        distance, 2,
-                        NULL, 
-                        si->arg, si->args);
+  plugin->env->receive (plugin->env->cls,
+                        &si->sender, hdr, distance, 2, NULL, si->arg, si->args);
 }
 
 
@@ -617,55 +606,56 @@ process_inbound_tokenized_messages (void *cls,
  */
 static void
 process_udp_message (struct Plugin *plugin,
-                     const struct UDPMessage *msg,
-                     const struct sockaddr *sender_addr,
-                     socklen_t sender_addr_len)
+                     const struct UDPMessage *msg,
+                     const struct sockaddr *sender_addr,
+                     socklen_t sender_addr_len)
 {
   struct SourceInformation si;
   struct IPv4UdpAddress u4;
   struct IPv6UdpAddress u6;
   const void *arg;
   size_t args;
-                                          
+
   if (0 != ntohl (msg->reserved))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
-  if (ntohs (msg->header.size) < sizeof (struct GNUNET_MessageHeader) + sizeof (struct UDPMessage))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  if (ntohs (msg->header.size) <
+      sizeof (struct GNUNET_MessageHeader) + sizeof (struct UDPMessage))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
   /* convert address */
   switch (sender_addr->sa_family)
-    {
-    case AF_INET:
-      GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in));
-      u4.ipv4_addr = ((struct sockaddr_in *) sender_addr)->sin_addr.s_addr;
-      u4.u4_port = ((struct sockaddr_in *) sender_addr)->sin_port;
-      arg = &u4;
-      args = sizeof (u4);
-      break;
-    case AF_INET6:
-      GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in6));
-      u6.ipv6_addr = ((struct sockaddr_in6*) sender_addr)->sin6_addr;
-      u6.u6_port = ((struct sockaddr_in6 *) sender_addr)->sin6_port;
-      arg = &u6;
-      args = sizeof (u6);    
-      break;
-    default:
-      GNUNET_break (0);
-      return;
-    }
+  {
+  case AF_INET:
+    GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in));
+    u4.ipv4_addr = ((struct sockaddr_in *) sender_addr)->sin_addr.s_addr;
+    u4.u4_port = ((struct sockaddr_in *) sender_addr)->sin_port;
+    arg = &u4;
+    args = sizeof (u4);
+    break;
+  case AF_INET6:
+    GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in6));
+    u6.ipv6_addr = ((struct sockaddr_in6 *) sender_addr)->sin6_addr;
+    u6.u6_port = ((struct sockaddr_in6 *) sender_addr)->sin6_port;
+    arg = &u6;
+    args = sizeof (u6);
+    break;
+  default:
+    GNUNET_break (0);
+    return;
+  }
 #if DEBUG_UDP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "udp",
-                   "Received message with %u bytes from peer `%s' at `%s'\n",
-                   (unsigned int) ntohs (msg->header.size),
-                   GNUNET_i2s (&msg->sender),
-                   GNUNET_a2s (sender_addr, sender_addr_len));
+                   "udp",
+                   "Received message with %u bytes from peer `%s' at `%s'\n",
+                   (unsigned int) ntohs (msg->header.size),
+                   GNUNET_i2s (&msg->sender),
+                   GNUNET_a2s (sender_addr, sender_addr_len));
 #endif
 
   /* iterate over all embedded messages */
@@ -673,11 +663,10 @@ process_udp_message (struct Plugin *plugin,
   si.arg = arg;
   si.args = args;
   GNUNET_SERVER_mst_receive (plugin->mst,
-                             &si,
-                             (const char*) &msg[1],
-                             ntohs (msg->header.size) - sizeof (struct UDPMessage),
-                             GNUNET_YES,
-                             GNUNET_NO);
+                             &si,
+                             (const char *) &msg[1],
+                             ntohs (msg->header.size) -
+                             sizeof (struct UDPMessage), GNUNET_YES, GNUNET_NO);
 }
 
 
@@ -688,26 +677,24 @@ process_udp_message (struct Plugin *plugin,
  * @param msg the message
  */
 static void
-fragment_msg_proc (void *cls,
-                   const struct GNUNET_MessageHeader *msg)
+fragment_msg_proc (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct ReceiveContext *rc = cls;
 
   if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE)
-    {
-      GNUNET_break (0);
-      return;
-    }
-  if (ntohs (msg->size) < sizeof(struct UDPMessage))
-    {
-      GNUNET_break (0);
-      return;
-    }   
+  {
+    GNUNET_break (0);
+    return;
+  }
+  if (ntohs (msg->size) < sizeof (struct UDPMessage))
+  {
+    GNUNET_break (0);
+    return;
+  }
   process_udp_message (rc->plugin,
-                       (const struct UDPMessage*) msg,
-                       rc->src_addr,
-                       rc->addr_len);
-}                  
+                       (const struct UDPMessage *) msg,
+                       rc->src_addr, rc->addr_len);
+}
 
 
 /**
@@ -718,9 +705,7 @@ fragment_msg_proc (void *cls,
  * @param msg ack to transmit
  */
 static void
-ack_proc (void *cls,
-          uint32_t id,
-          const struct GNUNET_MessageHeader *msg)
+ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg)
 {
   struct ReceiveContext *rc = cls;
   size_t msize = sizeof (struct UDPMessage) + ntohs (msg->size);
@@ -729,22 +714,20 @@ ack_proc (void *cls,
 
 #if DEBUG_UDP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "udp",
-                   "Sending ACK to `%s'\n",
-                   GNUNET_a2s (rc->src_addr, 
-                               (rc->src_addr->sa_family == AF_INET)
-                               ? sizeof (struct sockaddr_in) 
-                               : sizeof (struct sockaddr_in6)));
+                   "udp",
+                   "Sending ACK to `%s'\n",
+                   GNUNET_a2s (rc->src_addr,
+                               (rc->src_addr->sa_family == AF_INET)
+                               ? sizeof (struct sockaddr_in)
+                               : sizeof (struct sockaddr_in6)));
 #endif
-  udp = (struct UDPMessage*) buf;
+  udp = (struct UDPMessage *) buf;
   udp->header.size = htons ((uint16_t) msize);
   udp->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK);
   udp->reserved = htonl (0);
   udp->sender = *rc->plugin->env->my_identity;
   memcpy (&udp[1], msg, ntohs (msg->size));
-  (void) udp_send (rc->plugin, 
-                   rc->src_addr,
-                   &udp->header);
+  (void) udp_send (rc->plugin, rc->src_addr, &udp->header);
 }
 
 
@@ -782,21 +765,18 @@ struct FindReceiveContext
  */
 static int
 find_receive_context (void *cls,
-                      struct GNUNET_CONTAINER_HeapNode *node,
-                      void *element,
-                      GNUNET_CONTAINER_HeapCostType cost)
+                      struct GNUNET_CONTAINER_HeapNode *node,
+                      void *element, GNUNET_CONTAINER_HeapCostType cost)
 {
   struct FindReceiveContext *frc = cls;
   struct ReceiveContext *e = element;
 
-  if ( (frc->addr_len == e->addr_len) &&
-       (0 == memcmp (frc->addr,
-                     e->src_addr,
-                     frc->addr_len) ) )
-    {
-      frc->rc = e;
-      return GNUNET_NO;
-    }
+  if ((frc->addr_len == e->addr_len) &&
+      (0 == memcmp (frc->addr, e->src_addr, frc->addr_len)))
+  {
+    frc->rc = e;
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -808,8 +788,7 @@ find_receive_context (void *cls,
  * @param rsock socket to read from
  */
 static void
-udp_read (struct Plugin *plugin,
-          struct GNUNET_NETWORK_Handle *rsock)
+udp_read (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock)
 {
   socklen_t fromlen;
   char addr[32];
@@ -824,144 +803,142 @@ udp_read (struct Plugin *plugin,
   struct FindReceiveContext frc;
 
   fromlen = sizeof (addr);
-  memset (&addr, 0, sizeof(addr));
+  memset (&addr, 0, sizeof (addr));
   ret = GNUNET_NETWORK_socket_recvfrom (rsock, buf, sizeof (buf),
-                                        (struct sockaddr *)&addr, &fromlen);
+                                        (struct sockaddr *) &addr, &fromlen);
   if (ret < sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 #if DEBUG_UDP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "UDP received %u-byte message from `%s'\n",
-              (unsigned int) ret,
-              GNUNET_a2s ((const struct sockaddr*) addr, fromlen));
+              "UDP received %u-byte message from `%s'\n",
+              (unsigned int) ret,
+              GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
 #endif
   msg = (const struct GNUNET_MessageHeader *) buf;
   if (ret != ntohs (msg->size))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE:
+    if (ntohs (msg->size) < sizeof (struct UDPMessage))
     {
       GNUNET_break_op (0);
       return;
     }
-  switch (ntohs (msg->type))
+    process_udp_message (plugin,
+                         (const struct UDPMessage *) msg,
+                         (const struct sockaddr *) addr, fromlen);
+    return;
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK:
+    if (ntohs (msg->size) <
+        sizeof (struct UDPMessage) + sizeof (struct GNUNET_MessageHeader))
     {
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE:
-      if (ntohs (msg->size) < sizeof (struct UDPMessage))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      process_udp_message (plugin,
-                           (const struct UDPMessage *) msg,
-                           (const struct sockaddr*) addr,
-                           fromlen);
+      GNUNET_break_op (0);
       return;
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK:
-      if (ntohs (msg->size) < sizeof (struct UDPMessage) + sizeof (struct GNUNET_MessageHeader))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      udp = (const struct UDPMessage *) msg;
-      if (ntohl (udp->reserved) != 0)
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      ack = (const struct GNUNET_MessageHeader*) &udp[1];      
-      if (ntohs (ack->size) != ntohs (msg->size) - sizeof (struct UDPMessage))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
+    }
+    udp = (const struct UDPMessage *) msg;
+    if (ntohl (udp->reserved) != 0)
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    ack = (const struct GNUNET_MessageHeader *) &udp[1];
+    if (ntohs (ack->size) != ntohs (msg->size) - sizeof (struct UDPMessage))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
 #if DEBUG_UDP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
-                  (unsigned int) ntohs (msg->size),
-                  GNUNET_i2s (&udp->sender),
-                  GNUNET_a2s ((const struct sockaddr*) addr, fromlen));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
+                (unsigned int) ntohs (msg->size),
+                GNUNET_i2s (&udp->sender),
+                GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
 #endif
 
-      peer_session = find_session (plugin, &udp->sender);
-      if (NULL == peer_session)
-        {
+    peer_session = find_session (plugin, &udp->sender);
+    if (NULL == peer_session)
+    {
 #if DEBUG_UDP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Session for ACK not found, dropping ACK!\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Session for ACK not found, dropping ACK!\n");
 #endif
-          return; 
-        }
-      if (GNUNET_OK !=
-          GNUNET_FRAGMENT_process_ack (peer_session->frag,
-                                       ack))
-        return; 
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
-                                                           &udp->sender.hashPubKey,
-                                                           peer_session));
-      plugin->last_expected_delay = GNUNET_FRAGMENT_context_destroy (peer_session->frag);
-      peer_session->cont (peer_session->cont_cls,
-                          &udp->sender, 
-                          GNUNET_OK);
-      GNUNET_free (peer_session);
       return;
-    case GNUNET_MESSAGE_TYPE_FRAGMENT:
-      frc.rc = NULL;
-      frc.addr = (const struct sockaddr*) addr;
-      frc.addr_len = fromlen;
-      GNUNET_CONTAINER_heap_iterate (plugin->defrags,
-                                     &find_receive_context,
-                                     &frc);
-      now = GNUNET_TIME_absolute_get ();
-      rc = frc.rc;
-      if (rc == NULL)
-        {
-          /* need to create a new RC */
-          rc = GNUNET_malloc (sizeof (struct ReceiveContext) + fromlen);
-          memcpy (&rc[1], addr, fromlen);
-          rc->src_addr = (const struct sockaddr*) &rc[1];
-          rc->addr_len = fromlen;
-          rc->plugin = plugin;
-          rc->defrag = GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
-                                                         UDP_MTU,
-                                                         UDP_MAX_MESSAGES_IN_DEFRAG,
-                                                         rc,
-                                                         &fragment_msg_proc,
-                                                         &ack_proc);
-          rc->hnode = GNUNET_CONTAINER_heap_insert (plugin->defrags,
-                                                    rc,
-                                                    (GNUNET_CONTAINER_HeapCostType) now.abs_value);
-        }
+    }
+    if (GNUNET_OK != GNUNET_FRAGMENT_process_ack (peer_session->frag, ack))
+      return;
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
+                                                         &udp->
+                                                         sender.hashPubKey,
+                                                         peer_session));
+    plugin->last_expected_delay =
+        GNUNET_FRAGMENT_context_destroy (peer_session->frag);
+    peer_session->cont (peer_session->cont_cls, &udp->sender, GNUNET_OK);
+    GNUNET_free (peer_session);
+    return;
+  case GNUNET_MESSAGE_TYPE_FRAGMENT:
+    frc.rc = NULL;
+    frc.addr = (const struct sockaddr *) addr;
+    frc.addr_len = fromlen;
+    GNUNET_CONTAINER_heap_iterate (plugin->defrags,
+                                   &find_receive_context, &frc);
+    now = GNUNET_TIME_absolute_get ();
+    rc = frc.rc;
+    if (rc == NULL)
+    {
+      /* need to create a new RC */
+      rc = GNUNET_malloc (sizeof (struct ReceiveContext) + fromlen);
+      memcpy (&rc[1], addr, fromlen);
+      rc->src_addr = (const struct sockaddr *) &rc[1];
+      rc->addr_len = fromlen;
+      rc->plugin = plugin;
+      rc->defrag = GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
+                                                     UDP_MTU,
+                                                     UDP_MAX_MESSAGES_IN_DEFRAG,
+                                                     rc,
+                                                     &fragment_msg_proc,
+                                                     &ack_proc);
+      rc->hnode = GNUNET_CONTAINER_heap_insert (plugin->defrags,
+                                                rc,
+                                                (GNUNET_CONTAINER_HeapCostType)
+                                                now.abs_value);
+    }
 #if DEBUG_UDP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "UDP processes %u-byte fragment from `%s'\n",
-                  (unsigned int) ntohs (msg->size),
-                  GNUNET_a2s ((const struct sockaddr*) addr, fromlen));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "UDP processes %u-byte fragment from `%s'\n",
+                (unsigned int) ntohs (msg->size),
+                GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
 #endif
 
-      if (GNUNET_OK == 
-          GNUNET_DEFRAGMENT_process_fragment (rc->defrag,
-                                              msg))
-        {
-          /* keep this 'rc' from expiring */
-          GNUNET_CONTAINER_heap_update_cost (plugin->defrags,
-                                             rc->hnode,
-                                             (GNUNET_CONTAINER_HeapCostType) now.abs_value);
-        }
-      if (GNUNET_CONTAINER_heap_get_size (plugin->defrags) > UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
-        {
-          /* remove 'rc' that was inactive the longest */
-          rc = GNUNET_CONTAINER_heap_remove_root (plugin->defrags);
-          GNUNET_assert (NULL != rc);
-          GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
-          GNUNET_free (rc);
-        }      
-      return;
-    default:
-      GNUNET_break_op (0);
-      return;
+    if (GNUNET_OK == GNUNET_DEFRAGMENT_process_fragment (rc->defrag, msg))
+    {
+      /* keep this 'rc' from expiring */
+      GNUNET_CONTAINER_heap_update_cost (plugin->defrags,
+                                         rc->hnode,
+                                         (GNUNET_CONTAINER_HeapCostType)
+                                         now.abs_value);
     }
+    if (GNUNET_CONTAINER_heap_get_size (plugin->defrags) >
+        UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
+    {
+      /* remove 'rc' that was inactive the longest */
+      rc = GNUNET_CONTAINER_heap_remove_root (plugin->defrags);
+      GNUNET_assert (NULL != rc);
+      GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
+      GNUNET_free (rc);
+    }
+    return;
+  default:
+    GNUNET_break_op (0);
+    return;
+  }
 }
 
 
@@ -974,28 +951,25 @@ udp_read (struct Plugin *plugin,
  * @param tc the scheduling context (for rescheduling this function again)
  */
 static void
-udp_plugin_select (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
 
   plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
-  if ( (NULL != plugin->sockv4) &&
-       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
-                                    plugin->sockv4)) )
+  if ((NULL != plugin->sockv4) &&
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4)))
     udp_read (plugin, plugin->sockv4);
-  if ( (NULL != plugin->sockv6) &&
-       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
-                                    plugin->sockv6)) )
+  if ((NULL != plugin->sockv6) &&
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6)))
     udp_read (plugin, plugin->sockv6);
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &udp_plugin_select, plugin);
-  
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &udp_plugin_select, plugin);
+
 }
 
 
@@ -1011,8 +985,7 @@ udp_plugin_select (void *cls,
 static int
 check_port (struct Plugin *plugin, uint16_t in_port)
 {
-  if ( (in_port == plugin->port) ||
-       (in_port == plugin->aport) )
+  if ((in_port == plugin->port) || (in_port == plugin->aport))
     return GNUNET_OK;
   return GNUNET_SYSERR;
 }
@@ -1035,9 +1008,7 @@ check_port (struct Plugin *plugin, uint16_t in_port)
  *
  */
 static int
-udp_plugin_check_address (void *cls,
-                          const void *addr,
-                          size_t addrlen)
+udp_plugin_check_address (void *cls, const void *addr, size_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct IPv4UdpAddress *v4;
@@ -1045,37 +1016,35 @@ udp_plugin_check_address (void *cls,
 
   if ((addrlen != sizeof (struct IPv4UdpAddress)) &&
       (addrlen != sizeof (struct IPv6UdpAddress)))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   if (addrlen == sizeof (struct IPv4UdpAddress))
-    {
-      v4 = (struct IPv4UdpAddress *) addr;
-      if (GNUNET_OK !=
-          check_port (plugin, ntohs (v4->u4_port)))
-        return GNUNET_SYSERR;
-      if (GNUNET_OK !=
-          GNUNET_NAT_test_address (plugin->nat, 
-                                   &v4->ipv4_addr, sizeof (struct in_addr)))
-        return GNUNET_SYSERR;
-    }
+  {
+    v4 = (struct IPv4UdpAddress *) addr;
+    if (GNUNET_OK != check_port (plugin, ntohs (v4->u4_port)))
+      return GNUNET_SYSERR;
+    if (GNUNET_OK !=
+        GNUNET_NAT_test_address (plugin->nat,
+                                 &v4->ipv4_addr, sizeof (struct in_addr)))
+      return GNUNET_SYSERR;
+  }
   else
+  {
+    v6 = (struct IPv6UdpAddress *) addr;
+    if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
     {
-      v6 = (struct IPv6UdpAddress *) addr;
-      if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
-        {
-          GNUNET_break_op (0);
-          return GNUNET_SYSERR;
-        }
-      if (GNUNET_OK !=
-          check_port (plugin, ntohs (v6->u6_port)))
-        return GNUNET_SYSERR;
-      if (GNUNET_OK !=
-          GNUNET_NAT_test_address (plugin->nat,
-                                   &v6->ipv6_addr, sizeof (struct in6_addr)))
-        return GNUNET_SYSERR;
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
     }
+    if (GNUNET_OK != check_port (plugin, ntohs (v6->u6_port)))
+      return GNUNET_SYSERR;
+    if (GNUNET_OK !=
+        GNUNET_NAT_test_address (plugin->nat,
+                                 &v6->ipv6_addr, sizeof (struct in6_addr)))
+      return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -1091,10 +1060,8 @@ udp_plugin_check_address (void *cls,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-udp_address_to_string (void *cls,
-                       const void *addr,
-                       size_t addrlen)
+static const char *
+udp_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   static char rbuf[INET6_ADDRSTRLEN + 10];
   char buf[INET6_ADDRSTRLEN];
@@ -1107,32 +1074,28 @@ udp_address_to_string (void *cls,
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6UdpAddress))
-    {
-      t6 = addr;
-      af = AF_INET6;
-      port = ntohs (t6->u6_port);
-      memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
-      sb = &a6;
-    }
+  {
+    t6 = addr;
+    af = AF_INET6;
+    port = ntohs (t6->u6_port);
+    memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
+    sb = &a6;
+  }
   else if (addrlen == sizeof (struct IPv4UdpAddress))
-    {
-      t4 = addr;
-      af = AF_INET;
-      port = ntohs (t4->u4_port);
-      memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
-      sb = &a4;
-    }
+  {
+    t4 = addr;
+    af = AF_INET;
+    port = ntohs (t4->u4_port);
+    memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
+    sb = &a4;
+  }
   else
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
   inet_ntop (af, sb, buf, INET6_ADDRSTRLEN);
-  GNUNET_snprintf (rbuf,
-                   sizeof (rbuf),
-                   "%s:%u",
-                   buf,
-                   port);
+  GNUNET_snprintf (rbuf, sizeof (rbuf), "%s:%u", buf, port);
   return rbuf;
 }
 
@@ -1172,15 +1135,12 @@ append_port (void *cls, const char *hostname)
   char *ret;
 
   if (hostname == NULL)
-    {
-      ppc->asc (ppc->asc_cls, NULL);
-      GNUNET_free (ppc);
-      return;
-    }
-  GNUNET_asprintf (&ret,
-                   "%s:%d",
-                   hostname, 
-                   ppc->port);
+  {
+    ppc->asc (ppc->asc_cls, NULL);
+    GNUNET_free (ppc);
+    return;
+  }
+  GNUNET_asprintf (&ret, "%s:%d", hostname, ppc->port);
   ppc->asc (ppc->asc_cls, ret);
   GNUNET_free (ret);
 }
@@ -1220,50 +1180,45 @@ udp_plugin_address_pretty_printer (void *cls,
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6UdpAddress))
-    {
-      u6 = addr;
-      memset (&a6, 0, sizeof (a6));
-      a6.sin6_family = AF_INET6;
+  {
+    u6 = addr;
+    memset (&a6, 0, sizeof (a6));
+    a6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      a6.sin6_len = sizeof (a6);
+    a6.sin6_len = sizeof (a6);
 #endif
-      a6.sin6_port = u6->u6_port;
-      memcpy (&a6.sin6_addr,
-              &u6->ipv6_addr,
-              sizeof (struct in6_addr));
-      port = ntohs (u6->u6_port);
-      sb = &a6;
-      sbs = sizeof (a6);
-    }
+    a6.sin6_port = u6->u6_port;
+    memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof (struct in6_addr));
+    port = ntohs (u6->u6_port);
+    sb = &a6;
+    sbs = sizeof (a6);
+  }
   else if (addrlen == sizeof (struct IPv4UdpAddress))
-    {
-      u4 = addr;
-      memset (&a4, 0, sizeof (a4));
-      a4.sin_family = AF_INET;
+  {
+    u4 = addr;
+    memset (&a4, 0, sizeof (a4));
+    a4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      a4.sin_len = sizeof (a4);
+    a4.sin_len = sizeof (a4);
 #endif
-      a4.sin_port = u4->u4_port;
-      a4.sin_addr.s_addr = u4->ipv4_addr;
-      port = ntohs (u4->u4_port);
-      sb = &a4;
-      sbs = sizeof (a4);
-    }
+    a4.sin_port = u4->u4_port;
+    a4.sin_addr.s_addr = u4->ipv4_addr;
+    port = ntohs (u4->u4_port);
+    sb = &a4;
+    sbs = sizeof (a4);
+  }
   else
-    {
-      /* invalid address */
-      GNUNET_break_op (0);
-      asc (asc_cls, NULL);
-      return;
-    }
+  {
+    /* invalid address */
+    GNUNET_break_op (0);
+    asc (asc_cls, NULL);
+    return;
+  }
   ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext));
   ppc->asc = asc;
   ppc->asc_cls = asc_cls;
   ppc->port = port;
-  GNUNET_RESOLVER_hostname_get (sb,
-                                sbs,
-                                !numeric, timeout,
-                                &append_port, ppc);
+  GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
 }
 
 
@@ -1278,9 +1233,8 @@ udp_plugin_address_pretty_printer (void *cls,
  */
 static void
 udp_nat_port_map_callback (void *cls,
-                           int add_remove,
-                           const struct sockaddr *addr,
-                           socklen_t addrlen)
+                           int add_remove,
+                           const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct IPv4UdpAddress u4;
@@ -1290,31 +1244,29 @@ udp_nat_port_map_callback (void *cls,
 
   /* convert 'addr' to our internal format */
   switch (addr->sa_family)
-    {
-    case AF_INET:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
-      u4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
-      u4.u4_port = ((struct sockaddr_in *) addr)->sin_port;
-      arg = &u4;
-      args = sizeof (u4);
-      break;
-    case AF_INET6:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
-      memcpy (&u6.ipv6_addr,
-              &((struct sockaddr_in6 *) addr)->sin6_addr,
-              sizeof (struct in6_addr));
-      u6.u6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
-      arg = &u6;
-      args = sizeof (u6);    
-      break;
-    default:
-      GNUNET_break (0);
-      return;
-    }
+  {
+  case AF_INET:
+    GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+    u4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
+    u4.u4_port = ((struct sockaddr_in *) addr)->sin_port;
+    arg = &u4;
+    args = sizeof (u4);
+    break;
+  case AF_INET6:
+    GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
+    memcpy (&u6.ipv6_addr,
+            &((struct sockaddr_in6 *) addr)->sin6_addr,
+            sizeof (struct in6_addr));
+    u6.u6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
+    arg = &u6;
+    args = sizeof (u6);
+    break;
+  default:
+    GNUNET_break (0);
+    return;
+  }
   /* modify our published address list */
-  plugin->env->notify_address (plugin->env->cls,
-                               add_remove,
-                               arg, args);
+  plugin->env->notify_address (plugin->env->cls, add_remove, arg, args);
 }
 
 
@@ -1345,38 +1297,32 @@ libgnunet_plugin_transport_udp_init (void *cls)
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-udp",
-                                             "PORT",
-                                             &port))
+                                             "transport-udp", "PORT", &port))
     port = 2086;
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-udp",
-                                             "MAX_BPS",
-                                             &udp_max_bps))
-    udp_max_bps = 1024 * 1024 * 50; /* 50 MB/s == infinity for practical purposes */
+                                             "transport-udp",
+                                             "MAX_BPS", &udp_max_bps))
+    udp_max_bps = 1024 * 1024 * 50;     /* 50 MB/s == infinity for practical purposes */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-udp",
-                                             "ADVERTISED_PORT",
-                                             &aport))
+                                             "transport-udp",
+                                             "ADVERTISED_PORT", &aport))
     aport = port;
   if (port > 65535)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Given `%s' option is out of range: %llu > %u\n"),
-                  "PORT",
-                  port,
-                  65535);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Given `%s' option is out of range: %llu > %u\n"),
+                "PORT", port, 65535);
+    return NULL;
+  }
   memset (&serverAddrv6, 0, sizeof (serverAddrv6));
   memset (&serverAddrv4, 0, sizeof (serverAddrv4));
 
   plugin = GNUNET_malloc (sizeof (struct Plugin));
   GNUNET_BANDWIDTH_tracker_init (&plugin->tracker,
-                                 GNUNET_BANDWIDTH_value_init ((uint32_t) udp_max_bps),
-                                 30);
+                                 GNUNET_BANDWIDTH_value_init ((uint32_t)
+                                                              udp_max_bps), 30);
   plugin->last_expected_delay = GNUNET_TIME_UNIT_SECONDS;
   plugin->port = port;
   plugin->aport = aport;
@@ -1390,178 +1336,167 @@ libgnunet_plugin_transport_udp_init (void *cls)
   api->address_to_string = &udp_address_to_string;
   api->check_address = &udp_plugin_check_address;
 
-  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string(env->cfg, 
-                                                          "transport-udp", 
-                                                          "BINDTO", 
-                                                          &plugin->bind4_address))
+  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                                           "transport-udp",
+                                                           "BINDTO",
+                                                           &plugin->bind4_address))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Binding udp plugin to specific address: `%s'\n",
+                plugin->bind4_address);
+    if (1 != inet_pton (AF_INET, plugin->bind4_address, &serverAddrv4.sin_addr))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 
-                 "Binding udp plugin to specific address: `%s'\n", 
-                 plugin->bind4_address);
-      if (1 != inet_pton(AF_INET,
-                         plugin->bind4_address, 
-                         &serverAddrv4.sin_addr))
-        {
-          GNUNET_free (plugin->bind4_address);
-          GNUNET_free (plugin);
-          GNUNET_free (api);
-          return NULL;
-        }
+      GNUNET_free (plugin->bind4_address);
+      GNUNET_free (plugin);
+      GNUNET_free (api);
+      return NULL;
     }
-
-  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string(env->cfg, 
-                                                          "transport-udp",
-                                                          "BINDTO6", 
-                                                          &plugin->bind6_address))
+  }
+
+  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                                           "transport-udp",
+                                                           "BINDTO6",
+                                                           &plugin->bind6_address))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Binding udp plugin to specific address: `%s'\n",
+                plugin->bind6_address);
+    if (1 != inet_pton (AF_INET6,
+                        plugin->bind6_address, &serverAddrv6.sin6_addr))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Binding udp plugin to specific address: `%s'\n",
-                 plugin->bind6_address);
-      if (1 != inet_pton(AF_INET6, 
-                         plugin->bind6_address, 
-                         &serverAddrv6.sin6_addr))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     _("Invalid IPv6 address: `%s'\n"),
-                     plugin->bind6_address);
-          GNUNET_free_non_null (plugin->bind4_address);
-          GNUNET_free (plugin->bind6_address);
-          GNUNET_free (plugin);
-          GNUNET_free (api);
-          return NULL;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Invalid IPv6 address: `%s'\n"), plugin->bind6_address);
+      GNUNET_free_non_null (plugin->bind4_address);
+      GNUNET_free (plugin->bind6_address);
+      GNUNET_free (plugin);
+      GNUNET_free (api);
+      return NULL;
     }
+  }
 
-  plugin->defrags = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-  plugin->sessions = GNUNET_CONTAINER_multihashmap_create (UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG * 2);
+  plugin->defrags =
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  plugin->sessions =
+      GNUNET_CONTAINER_multihashmap_create (UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG
+                                            * 2);
   sockets_created = 0;
-  if ( (GNUNET_YES !=
-        GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
-                                              "nat",
-                                              "DISABLEV6")))
+  if ((GNUNET_YES !=
+       GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
+                                             "nat", "DISABLEV6")))
+  {
+    plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
+    if (NULL == plugin->sockv6)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
+    }
+    else
     {
-      plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
-      if (NULL == plugin->sockv6)
-        {
-          GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
-        }
-      else
-        {
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          serverAddrv6.sin6_len = sizeof (serverAddrv6);
+      serverAddrv6.sin6_len = sizeof (serverAddrv6);
 #endif
-          serverAddrv6.sin6_family = AF_INET6;
-          serverAddrv6.sin6_addr = in6addr_any;
-          serverAddrv6.sin6_port = htons (plugin->port);
-          addrlen = sizeof (serverAddrv6);
-          serverAddr = (struct sockaddr *) &serverAddrv6;
+      serverAddrv6.sin6_family = AF_INET6;
+      serverAddrv6.sin6_addr = in6addr_any;
+      serverAddrv6.sin6_port = htons (plugin->port);
+      addrlen = sizeof (serverAddrv6);
+      serverAddr = (struct sockaddr *) &serverAddrv6;
 #if DEBUG_UDP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                           "Binding to IPv6 port %d\n",
-                           ntohs(serverAddrv6.sin6_port));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Binding to IPv6 port %d\n", ntohs (serverAddrv6.sin6_port));
 #endif
-          tries = 0;
-          while (GNUNET_NETWORK_socket_bind (plugin->sockv6, 
-                                             serverAddr, addrlen) !=
-                 GNUNET_OK)
-            {
-              serverAddrv6.sin6_port
-                = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
+      tries = 0;
+      while (GNUNET_NETWORK_socket_bind (plugin->sockv6,
+                                         serverAddr, addrlen) != GNUNET_OK)
+      {
+        serverAddrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);        /* Find a good, non-root port */
 #if DEBUG_UDP
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                               "IPv6 Binding failed, trying new port %d\n",
-                               ntohs(serverAddrv6.sin6_port));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "IPv6 Binding failed, trying new port %d\n",
+                    ntohs (serverAddrv6.sin6_port));
 #endif
-              tries++;
-              if (tries > 10)
-                {
-                  GNUNET_NETWORK_socket_close (plugin->sockv6);
-                  plugin->sockv6 = NULL;
-                  break;
-                }       
-            }
-          if (plugin->sockv6 != NULL)
-            {
-              addrs[sockets_created] = (struct sockaddr*)  &serverAddrv6;
-              addrlens[sockets_created] = sizeof (serverAddrv6);
-              sockets_created++;
-            }
-        }
+        tries++;
+        if (tries > 10)
+        {
+          GNUNET_NETWORK_socket_close (plugin->sockv6);
+          plugin->sockv6 = NULL;
+          break;
+        }
+      }
+      if (plugin->sockv6 != NULL)
+      {
+        addrs[sockets_created] = (struct sockaddr *) &serverAddrv6;
+        addrlens[sockets_created] = sizeof (serverAddrv6);
+        sockets_created++;
+      }
     }
+  }
 
   plugin->mst = GNUNET_SERVER_mst_create (&process_inbound_tokenized_messages,
-                                          plugin);
+                                          plugin);
   plugin->sockv4 = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 0);
   if (NULL == plugin->sockv4)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
+  }
   else
-    {
+  {
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      serverAddrv4.sin_len = sizeof (serverAddrv4);
+    serverAddrv4.sin_len = sizeof (serverAddrv4);
 #endif
-      serverAddrv4.sin_family = AF_INET;
-      serverAddrv4.sin_addr.s_addr = INADDR_ANY;
-      serverAddrv4.sin_port = htons (plugin->port);
-      addrlen = sizeof (serverAddrv4);
-      serverAddr = (struct sockaddr *) &serverAddrv4;
+    serverAddrv4.sin_family = AF_INET;
+    serverAddrv4.sin_addr.s_addr = INADDR_ANY;
+    serverAddrv4.sin_port = htons (plugin->port);
+    addrlen = sizeof (serverAddrv4);
+    serverAddr = (struct sockaddr *) &serverAddrv4;
 #if DEBUG_UDP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                       "Binding to IPv4 port %d\n",
-                       ntohs(serverAddrv4.sin_port));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Binding to IPv4 port %d\n", ntohs (serverAddrv4.sin_port));
 #endif
-      tries = 0;
-      while (GNUNET_NETWORK_socket_bind (plugin->sockv4, serverAddr, addrlen) !=
-             GNUNET_OK)
-        {
-          serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
+    tries = 0;
+    while (GNUNET_NETWORK_socket_bind (plugin->sockv4, serverAddr, addrlen) !=
+           GNUNET_OK)
+    {
+      serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);   /* Find a good, non-root port */
 #if DEBUG_UDP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                           "IPv4 Binding failed, trying new port %d\n",
-                           ntohs(serverAddrv4.sin_port));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "IPv4 Binding failed, trying new port %d\n",
+                  ntohs (serverAddrv4.sin_port));
 #endif
-          tries++;
-          if (tries > 10)
-            {
-              GNUNET_NETWORK_socket_close (plugin->sockv4);
-              plugin->sockv4 = NULL;
-              break;
-            }   
-        }
-      if (plugin->sockv4 != NULL)
-        {
-          addrs[sockets_created] = (struct sockaddr*) &serverAddrv4;
-          addrlens[sockets_created] = sizeof (serverAddrv4);
-          sockets_created++;
-        }
+      tries++;
+      if (tries > 10)
+      {
+        GNUNET_NETWORK_socket_close (plugin->sockv4);
+        plugin->sockv4 = NULL;
+        break;
+      }
     }
+    if (plugin->sockv4 != NULL)
+    {
+      addrs[sockets_created] = (struct sockaddr *) &serverAddrv4;
+      addrlens[sockets_created] = sizeof (serverAddrv4);
+      sockets_created++;
+    }
+  }
 
   plugin->rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_zero (plugin->rs);
   if (NULL != plugin->sockv4)
-    GNUNET_NETWORK_fdset_set (plugin->rs,
-                              plugin->sockv4);
+    GNUNET_NETWORK_fdset_set (plugin->rs, plugin->sockv4);
   if (NULL != plugin->sockv6)
-    GNUNET_NETWORK_fdset_set (plugin->rs,
-                              plugin->sockv6);
+    GNUNET_NETWORK_fdset_set (plugin->rs, plugin->sockv6);
 
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &udp_plugin_select, plugin);
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &udp_plugin_select, plugin);
   if (sockets_created == 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to open UDP sockets\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n"));
   plugin->nat = GNUNET_NAT_register (env->cfg,
-                                     GNUNET_NO,
-                                     port,
-                                     sockets_created,
-                                     (const struct sockaddr**) addrs, addrlens,
-                                     &udp_nat_port_map_callback, 
-                                     NULL,
-                                     plugin);
+                                     GNUNET_NO,
+                                     port,
+                                     sockets_created,
+                                     (const struct sockaddr **) addrs, addrlens,
+                                     &udp_nat_port_map_callback, NULL, plugin);
   return api;
 }
 
@@ -1575,9 +1510,7 @@ libgnunet_plugin_transport_udp_init (void *cls)
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-destroy_session (void *cls,
-                 const GNUNET_HashCode *key,
-                 void *value)
+destroy_session (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct PeerSession *peer_session = value;
 
@@ -1602,32 +1535,31 @@ libgnunet_plugin_transport_udp_done (void *cls)
 
   /* FIXME: clean up heap and hashmap */
   GNUNET_CONTAINER_multihashmap_iterate (plugin->sessions,
-                                         &destroy_session,
-                                         NULL);
+                                         &destroy_session, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (plugin->sessions);
   plugin->sessions = NULL;
   while (NULL != (rc = GNUNET_CONTAINER_heap_remove_root (plugin->defrags)))
-    {
-      GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
-      GNUNET_free (rc);
-    }
+  {
+    GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
+    GNUNET_free (rc);
+  }
   GNUNET_CONTAINER_heap_destroy (plugin->defrags);
-  
+
   if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (plugin->select_task);
-      plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (plugin->select_task);
+    plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (plugin->sockv4 != NULL)
-    {
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
-      plugin->sockv4 = NULL;
-    }
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
+    plugin->sockv4 = NULL;
+  }
   if (plugin->sockv6 != NULL)
-    {
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
-      plugin->sockv6 = NULL;
-    }
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
+    plugin->sockv6 = NULL;
+  }
   GNUNET_SERVER_mst_destroy (plugin->mst);
   GNUNET_NETWORK_fdset_destroy (plugin->rs);
   GNUNET_NAT_unregister (plugin->nat);
diff --git a/src/transport/plugin_transport_unix.c b/src/transport/plugin_transport_unix.c
index 2a7dc9065..22dda8e8b 100644
--- a/src/transport/plugin_transport_unix.c
+++ b/src/transport/plugin_transport_unix.c
@@ -375,26 +375,27 @@ unix_transport_server_stop (void *cls)
 
   pos = retry_list_head;
 
-  while(NULL != (pos = retry_list_head))
+  while (NULL != (pos = retry_list_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (retry_list_head, retry_list_tail, pos);
+    if (GNUNET_SCHEDULER_NO_TASK != pos->retry_ctx->retry_task)
     {
-      GNUNET_CONTAINER_DLL_remove(retry_list_head, retry_list_tail, pos);
-      if (GNUNET_SCHEDULER_NO_TASK != pos->retry_ctx->retry_task)
-        {
-          GNUNET_SCHEDULER_cancel(pos->retry_ctx->retry_task);
-        }
-      GNUNET_free(pos->retry_ctx->msg);
-      GNUNET_free(pos->retry_ctx->addr);
-      GNUNET_free(pos->retry_ctx);
-      GNUNET_free(pos);
+      GNUNET_SCHEDULER_cancel (pos->retry_ctx->retry_task);
     }
+    GNUNET_free (pos->retry_ctx->msg);
+    GNUNET_free (pos->retry_ctx->addr);
+    GNUNET_free (pos->retry_ctx);
+    GNUNET_free (pos);
+  }
 
   if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (plugin->select_task);
-      plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (plugin->select_task);
+    plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
+  }
 
-  GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->unix_sock.desc));
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_NETWORK_socket_close (plugin->unix_sock.desc));
   plugin->unix_sock.desc = NULL;
 
   return GNUNET_OK;
@@ -402,18 +403,17 @@ unix_transport_server_stop (void *cls)
 
 
 struct PeerSession *
-find_session (struct Plugin *plugin,
-              const struct GNUNET_PeerIdentity *peer)
+find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerSession *pos;
 
   pos = plugin->sessions;
   while (pos != NULL)
-    {
-      if (memcmp(&pos->target, peer, sizeof(struct GNUNET_PeerIdentity)) == 0)
-        return pos;
-      pos = pos->next;
-    }
+  {
+    if (memcmp (&pos->target, peer, sizeof (struct GNUNET_PeerIdentity)) == 0)
+      return pos;
+    pos = pos->next;
+  }
 
   return pos;
 }
@@ -430,8 +430,7 @@ unix_real_send (void *cls,
                 struct GNUNET_TIME_Relative timeout,
                 const void *addr,
                 size_t addrlen,
-                GNUNET_TRANSPORT_TransmitContinuation cont,
-                void *cont_cls);
+                GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls);
 
 /**
  * Retry sending a message.
@@ -439,18 +438,18 @@ unix_real_send (void *cls,
  * @param cls closure a struct RetrySendContext
  * @param tc context information
  */
-void retry_send_message (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext * tc)
+void
+retry_send_message (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct RetrySendContext *retry_ctx = cls;
 
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    {
-      GNUNET_free(retry_ctx->msg);
-      GNUNET_free(retry_ctx->addr);
-      GNUNET_free(retry_ctx);
-      return;
-    }
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  {
+    GNUNET_free (retry_ctx->msg);
+    GNUNET_free (retry_ctx->addr);
+    GNUNET_free (retry_ctx);
+    return;
+  }
 
   unix_real_send (retry_ctx->plugin,
                   retry_ctx,
@@ -461,9 +460,7 @@ void retry_send_message (void *cls,
                   retry_ctx->priority,
                   GNUNET_TIME_absolute_get_remaining (retry_ctx->timeout),
                   retry_ctx->addr,
-                  retry_ctx->addrlen,
-                  retry_ctx->cont,
-                  retry_ctx->cont_cls);
+                  retry_ctx->addrlen, retry_ctx->cont, retry_ctx->cont_cls);
   return;
 }
 
@@ -493,15 +490,14 @@ static ssize_t
 unix_real_send (void *cls,
                 struct RetrySendContext *incoming_retry_context,
                 struct GNUNET_NETWORK_Handle *send_handle,
-                const struct GNUNET_PeerIdentity *target,
-                const char *msgbuf,
-                size_t msgbuf_size,
-                unsigned int priority,
-                struct GNUNET_TIME_Relative timeout,
-                const void *addr,
-                size_t addrlen,
-                GNUNET_TRANSPORT_TransmitContinuation cont,
-                void *cont_cls)
+                const struct GNUNET_PeerIdentity *target,
+                const char *msgbuf,
+                size_t msgbuf_size,
+                unsigned int priority,
+                struct GNUNET_TIME_Relative timeout,
+                const void *addr,
+                size_t addrlen,
+                GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
   struct Plugin *plugin = cls;
   struct UNIXMessage *message;
@@ -516,26 +512,26 @@ unix_real_send (void *cls,
   int retry;
 
   if (send_handle == NULL)
-    {
+  {
 #if DEBUG_UNIX
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                       "unix_real_send with send_handle NULL!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "unix_real_send with send_handle NULL!\n");
 #endif
-      /* failed to open send socket for AF */
-      if (cont != NULL)
-        cont (cont_cls, target, GNUNET_SYSERR);
-      return 0;
-    }
+    /* failed to open send socket for AF */
+    if (cont != NULL)
+      cont (cont_cls, target, GNUNET_SYSERR);
+    return 0;
+  }
   if ((addr == NULL) || (addrlen == 0))
-    {
+  {
 #if DEBUG_UNIX
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                       "unix_real_send called without address, returning!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "unix_real_send called without address, returning!\n");
 #endif
-      if (cont != NULL)
-        cont (cont_cls, target, GNUNET_SYSERR);
-      return 0; /* Can never send if we don't have an address!! */
-    }
+    if (cont != NULL)
+      cont (cont_cls, target, GNUNET_SYSERR);
+    return 0;                   /* Can never send if we don't have an address!! */
+  }
 
   /* Build the message to be sent */
   message = GNUNET_malloc (sizeof (struct UNIXMessage) + msgbuf_size);
@@ -547,13 +543,13 @@ unix_real_send (void *cls,
           sizeof (struct GNUNET_PeerIdentity));
   memcpy (&message[1], msgbuf, msgbuf_size);
 
-  memset(&un, 0, sizeof(un));
+  memset (&un, 0, sizeof (un));
   un.sun_family = AF_UNIX;
   slen = strlen (addr) + 1;
   if (slen >= sizeof (un.sun_path))
     slen = sizeof (un.sun_path) - 1;
   sent = 0;
-  GNUNET_assert(slen < sizeof(un.sun_path));
+  GNUNET_assert (slen < sizeof (un.sun_path));
   memcpy (un.sun_path, addr, slen);
   un.sun_path[slen] = '\0';
   slen = sizeof (struct sockaddr_un);
@@ -563,104 +559,105 @@ unix_real_send (void *cls,
 #if HAVE_SOCKADDR_IN_SIN_LEN
   un.sun_len = (u_char) slen;
 #endif
-  sb = (struct sockaddr*) &un;
+  sb = (struct sockaddr *) &un;
   sbs = slen;
   retry = GNUNET_NO;
 
-  sent = GNUNET_NETWORK_socket_sendto(send_handle, message, ssize, sb, sbs);
+  sent = GNUNET_NETWORK_socket_sendto (send_handle, message, ssize, sb, sbs);
 
   if ((GNUNET_SYSERR == sent) && (errno == EAGAIN))
-          retry = GNUNET_YES;
+    retry = GNUNET_YES;
 
   if ((GNUNET_SYSERR == sent) && (errno == EMSGSIZE))
   {
-          socklen_t size = 0;
-          socklen_t len = sizeof (size);
-          GNUNET_NETWORK_socket_getsockopt ((struct GNUNET_NETWORK_Handle * ) send_handle,
-                          SOL_SOCKET,
-                          SO_SNDBUF,
-                          &size, &len);
-
-          if (size < ssize)
-          {
+    socklen_t size = 0;
+    socklen_t len = sizeof (size);
+
+    GNUNET_NETWORK_socket_getsockopt ((struct GNUNET_NETWORK_Handle *)
+                                      send_handle, SOL_SOCKET, SO_SNDBUF, &size,
+                                      &len);
+
+    if (size < ssize)
+    {
 #if DEBUG_UNIX
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Trying to increase socket buffer size from %i to %i for message size %i\n",
-              size,
-              ((ssize / 1000) + 2) * 1000, ssize);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Trying to increase socket buffer size from %i to %i for message size %i\n",
+                  size, ((ssize / 1000) + 2) * 1000, ssize);
 #endif
-                  size = ((ssize / 1000) + 2) * 1000;
-                  if (GNUNET_NETWORK_socket_setsockopt ((struct GNUNET_NETWORK_Handle * ) send_handle,
-                                  SOL_SOCKET,
-                                  SO_SNDBUF,
-                                  &size, sizeof(size)) == GNUNET_OK)
-                         retry = GNUNET_YES;
-                  else
-                         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
-          }
+      size = ((ssize / 1000) + 2) * 1000;
+      if (GNUNET_NETWORK_socket_setsockopt
+          ((struct GNUNET_NETWORK_Handle *) send_handle, SOL_SOCKET, SO_SNDBUF,
+           &size, sizeof (size)) == GNUNET_OK)
+        retry = GNUNET_YES;
+      else
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
+    }
   }
 
   if (retry == GNUNET_YES)
+  {
+    if (incoming_retry_context == NULL)
     {
-      if (incoming_retry_context == NULL)
-        {
-          retry_list_entry = GNUNET_malloc(sizeof(struct RetryList));
-          retry_ctx = GNUNET_malloc(sizeof(struct RetrySendContext));
-          retry_ctx->addr = GNUNET_malloc(addrlen);
-          retry_ctx->msg = GNUNET_malloc(msgbuf_size);
-          retry_ctx->plugin = plugin;
-          memcpy(retry_ctx->addr, addr, addrlen);
-          memcpy(retry_ctx->msg, msgbuf, msgbuf_size);
-          retry_ctx->msg_size = msgbuf_size;
-          retry_ctx->addrlen = addrlen;
-          retry_ctx->send_handle = send_handle;
-          retry_ctx->cont = cont;
-          retry_ctx->cont_cls = cont_cls;
-          retry_ctx->priority = priority;
-          retry_ctx->timeout = GNUNET_TIME_relative_to_absolute(timeout);
-          memcpy(&retry_ctx->target, target, sizeof(struct GNUNET_PeerIdentity));
-          retry_ctx->delay = GNUNET_TIME_UNIT_MILLISECONDS;
-          retry_ctx->retry_list_entry = retry_list_entry;
-          retry_list_entry->retry_ctx = retry_ctx;
-          GNUNET_CONTAINER_DLL_insert(retry_list_head, retry_list_tail, retry_list_entry);
-        }
-      else
-        {
-          retry_ctx = incoming_retry_context;
-          retry_ctx->delay = GNUNET_TIME_relative_multiply(retry_ctx->delay, 2);
-        }
-      retry_ctx->retry_task = GNUNET_SCHEDULER_add_delayed(retry_ctx->delay, &retry_send_message, retry_ctx);
-
-      //GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
-      GNUNET_free(message);
-      return ssize;
+      retry_list_entry = GNUNET_malloc (sizeof (struct RetryList));
+      retry_ctx = GNUNET_malloc (sizeof (struct RetrySendContext));
+      retry_ctx->addr = GNUNET_malloc (addrlen);
+      retry_ctx->msg = GNUNET_malloc (msgbuf_size);
+      retry_ctx->plugin = plugin;
+      memcpy (retry_ctx->addr, addr, addrlen);
+      memcpy (retry_ctx->msg, msgbuf, msgbuf_size);
+      retry_ctx->msg_size = msgbuf_size;
+      retry_ctx->addrlen = addrlen;
+      retry_ctx->send_handle = send_handle;
+      retry_ctx->cont = cont;
+      retry_ctx->cont_cls = cont_cls;
+      retry_ctx->priority = priority;
+      retry_ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+      memcpy (&retry_ctx->target, target, sizeof (struct GNUNET_PeerIdentity));
+      retry_ctx->delay = GNUNET_TIME_UNIT_MILLISECONDS;
+      retry_ctx->retry_list_entry = retry_list_entry;
+      retry_list_entry->retry_ctx = retry_ctx;
+      GNUNET_CONTAINER_DLL_insert (retry_list_head, retry_list_tail,
+                                   retry_list_entry);
     }
+    else
+    {
+      retry_ctx = incoming_retry_context;
+      retry_ctx->delay = GNUNET_TIME_relative_multiply (retry_ctx->delay, 2);
+    }
+    retry_ctx->retry_task =
+        GNUNET_SCHEDULER_add_delayed (retry_ctx->delay, &retry_send_message,
+                                      retry_ctx);
+
+    //GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
+    GNUNET_free (message);
+    return ssize;
+  }
 #if DEBUG_UNIX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "UNIX transmit %u-byte message to %s (%d: %s)\n",
-              (unsigned int) ssize,
-              GNUNET_a2s (sb, sbs),
-              (int) sent,
-              (sent < 0) ? STRERROR (errno) : "ok");
+              "UNIX transmit %u-byte message to %s (%d: %s)\n",
+              (unsigned int) ssize,
+              GNUNET_a2s (sb, sbs),
+              (int) sent, (sent < 0) ? STRERROR (errno) : "ok");
 #endif
   if (cont != NULL)
+  {
+    if (sent == GNUNET_SYSERR)
+      cont (cont_cls, target, GNUNET_SYSERR);
+    else
     {
-      if (sent == GNUNET_SYSERR)
-        cont (cont_cls, target, GNUNET_SYSERR);
-      else
-        {
-          cont (cont_cls, target, GNUNET_OK);
-        }
+      cont (cont_cls, target, GNUNET_OK);
     }
+  }
 
   if (incoming_retry_context != NULL)
-    {
-      GNUNET_CONTAINER_DLL_remove(retry_list_head, retry_list_tail, incoming_retry_context->retry_list_entry);
-      GNUNET_free(incoming_retry_context->retry_list_entry);
-      GNUNET_free(incoming_retry_context->msg);
-      GNUNET_free(incoming_retry_context->addr);
-      GNUNET_free(incoming_retry_context);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (retry_list_head, retry_list_tail,
+                                 incoming_retry_context->retry_list_entry);
+    GNUNET_free (incoming_retry_context->retry_list_entry);
+    GNUNET_free (incoming_retry_context->msg);
+    GNUNET_free (incoming_retry_context->addr);
+    GNUNET_free (incoming_retry_context);
+  }
 
   GNUNET_free (message);
   return sent;
@@ -693,16 +690,16 @@ unix_real_send (void *cls,
  */
 static ssize_t
 unix_plugin_send (void *cls,
-                     const struct GNUNET_PeerIdentity *target,
-                     const char *msgbuf,
-                     size_t msgbuf_size,
-                     unsigned int priority,
-                     struct GNUNET_TIME_Relative timeout,
-                     struct Session *session,
-                     const void *addr,
-                     size_t addrlen,
-                     int force_address,
-                     GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
+                  const struct GNUNET_PeerIdentity *target,
+                  const char *msgbuf,
+                  size_t msgbuf_size,
+                  unsigned int priority,
+                  struct GNUNET_TIME_Relative timeout,
+                  struct Session *session,
+                  const void *addr,
+                  size_t addrlen,
+                  int force_address,
+                  GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
   struct Plugin *plugin = cls;
   ssize_t sent;
@@ -712,17 +709,18 @@ unix_plugin_send (void *cls,
   GNUNET_assert (NULL == session);
 
 #if DEBUG_UNIX
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Asked to send message to `%s'\n", (char *)addr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asked to send message to `%s'\n",
+              (char *) addr);
 #endif
-  sent = unix_real_send(cls,
-                        NULL,
-                        plugin->unix_sock.desc,
-                        target,
-                        msgbuf, msgbuf_size,
-                        priority, timeout, addr, addrlen,
-                        cont, cont_cls);
+  sent = unix_real_send (cls,
+                         NULL,
+                         plugin->unix_sock.desc,
+                         target,
+                         msgbuf, msgbuf_size,
+                         priority, timeout, addr, addrlen, cont, cont_cls);
 #if DEBUG_UNIX
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sent %d bytes to `%s'\n", sent, (char *)addr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent %d bytes to `%s'\n", sent,
+              (char *) addr);
 #endif
   if (sent == GNUNET_SYSERR)
     return 0;
@@ -740,11 +738,10 @@ unix_plugin_send (void *cls,
  * @param fromlen the length of the address
  */
 static void
-unix_demultiplexer(struct Plugin *plugin,
-                   struct GNUNET_PeerIdentity *sender,
-                   const struct GNUNET_MessageHeader *currhdr,
-                   const struct sockaddr_un *un,
-                   size_t fromlen)
+unix_demultiplexer (struct Plugin *plugin,
+                    struct GNUNET_PeerIdentity *sender,
+                    const struct GNUNET_MessageHeader *currhdr,
+                    const struct sockaddr_un *un, size_t fromlen)
 {
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
 
@@ -753,14 +750,16 @@ unix_demultiplexer(struct Plugin *plugin,
   distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   distance[1].value = htonl (0);
 
-  GNUNET_assert(fromlen >= sizeof(struct sockaddr_un));
+  GNUNET_assert (fromlen >= sizeof (struct sockaddr_un));
 
 #if DEBUG_UNIX
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received message from %s\n", un->sun_path);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message from %s\n",
+              un->sun_path);
 #endif
   plugin->env->receive (plugin->env->cls, sender, currhdr,
-                       (const struct GNUNET_TRANSPORT_ATS_Information *) &distance, 2,
-                              NULL, un->sun_path, strlen(un->sun_path) + 1);
+                        (const struct GNUNET_TRANSPORT_ATS_Information *)
+                        &distance, 2, NULL, un->sun_path,
+                        strlen (un->sun_path) + 1);
 }
 
 
@@ -774,8 +773,7 @@ unix_demultiplexer(struct Plugin *plugin,
  *
  */
 static void
-unix_plugin_select (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+unix_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
   char buf[65536];
@@ -791,33 +789,35 @@ unix_plugin_select (void *cls,
   uint16_t csize;
 
   plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
 
-  addrlen = sizeof(un);
-  memset(&un, 0, sizeof(un));
-  GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->unix_sock.desc));
+  addrlen = sizeof (un);
+  memset (&un, 0, sizeof (un));
+  GNUNET_assert (GNUNET_NETWORK_fdset_isset
+                 (tc->read_ready, plugin->unix_sock.desc));
   ret =
-    GNUNET_NETWORK_socket_recvfrom (plugin->unix_sock.desc, buf, sizeof (buf),
-                                    (struct sockaddr *)&un, &addrlen);
+      GNUNET_NETWORK_socket_recvfrom (plugin->unix_sock.desc, buf, sizeof (buf),
+                                      (struct sockaddr *) &un, &addrlen);
 
   if (ret == GNUNET_SYSERR)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom");
-      plugin->select_task =
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom");
+    plugin->select_task =
         GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                      GNUNET_SCHEDULER_NO_TASK,
                                      GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
                                      NULL, &unix_plugin_select, plugin);
-      return;
-    }
+    return;
+  }
   else
   {
 #if LINUX
     un.sun_path[0] = '/';
 #endif
 #if DEBUG_UNIX
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Read %d bytes from socket %s\n", ret, &un.sun_path[0]);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read %d bytes from socket %s\n", ret,
+                &un.sun_path[0]);
 #endif
   }
 
@@ -825,40 +825,38 @@ unix_plugin_select (void *cls,
 
   msg = (struct UNIXMessage *) buf;
   csize = ntohs (msg->header.size);
-  if ( (csize < sizeof (struct UNIXMessage)) ||
-       (csize > ret) )
-    {
-      GNUNET_break_op (0);
-      plugin->select_task =
-        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                     GNUNET_SCHEDULER_NO_TASK,
-                                     GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                     NULL, &unix_plugin_select, plugin);
-      return;
-    }
-  msgbuf = (char *)&msg[1];
+  if ((csize < sizeof (struct UNIXMessage)) || (csize > ret))
+  {
+    GNUNET_break_op (0);
+    plugin->select_task =
+        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                     NULL, &unix_plugin_select, plugin);
+    return;
+  }
+  msgbuf = (char *) &msg[1];
   memcpy (&sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity));
   offset = 0;
   tsize = csize - sizeof (struct UNIXMessage);
   while (offset + sizeof (struct GNUNET_MessageHeader) <= tsize)
+  {
+    currhdr = (struct GNUNET_MessageHeader *) &msgbuf[offset];
+    csize = ntohs (currhdr->size);
+    if ((csize < sizeof (struct GNUNET_MessageHeader)) ||
+        (csize > tsize - offset))
     {
-      currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset];
-      csize = ntohs (currhdr->size);
-      if ( (csize < sizeof (struct GNUNET_MessageHeader)) ||
-           (csize > tsize - offset) )
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      unix_demultiplexer(plugin, &sender, currhdr,
-                         &un, sizeof(un));
-      offset += csize;
+      GNUNET_break_op (0);
+      break;
     }
+    unix_demultiplexer (plugin, &sender, currhdr, &un, sizeof (un));
+    offset += csize;
+  }
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &unix_plugin_select, plugin);
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &unix_plugin_select, plugin);
 }
 
 /**
@@ -876,7 +874,7 @@ unix_transport_server_start (void *cls)
   struct sockaddr_un un;
   size_t slen;
 
-  memset(&un, 0, sizeof(un));
+  memset (&un, 0, sizeof (un));
   un.sun_family = AF_UNIX;
   slen = strlen (plugin->unix_socket_path) + 1;
   if (slen >= sizeof (un.sun_path))
@@ -889,42 +887,40 @@ unix_transport_server_start (void *cls)
   un.sun_len = (u_char) slen;
 #endif
 
-  serverAddr = (struct sockaddr*) &un;
+  serverAddr = (struct sockaddr *) &un;
   addrlen = slen;
 #if LINUX
   un.sun_path[0] = '\0';
 #endif
 
-  plugin->unix_sock.desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
+  plugin->unix_sock.desc =
+      GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
   if (NULL == plugin->unix_sock.desc)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
-      return GNUNET_SYSERR;
-    }
-  if (GNUNET_NETWORK_socket_bind (plugin->unix_sock.desc, serverAddr, addrlen) !=
-      GNUNET_OK)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
-      GNUNET_NETWORK_socket_close (plugin->unix_sock.desc);
-      plugin->unix_sock.desc = NULL;
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_NETWORK_socket_bind (plugin->unix_sock.desc, serverAddr, addrlen)
+      != GNUNET_OK)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+    GNUNET_NETWORK_socket_close (plugin->unix_sock.desc);
+    plugin->unix_sock.desc = NULL;
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_UNIX
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, 
-                   "unix",
-                   "Bound to `%s'\n",
-                   &un.sun_path[0]);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "unix", "Bound to `%s'\n", &un.sun_path[0]);
 #endif
   plugin->rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_zero (plugin->rs);
-  GNUNET_NETWORK_fdset_set (plugin->rs,
-                            plugin->unix_sock.desc);
+  GNUNET_NETWORK_fdset_set (plugin->rs, plugin->unix_sock.desc);
 
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &unix_plugin_select, plugin);
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &unix_plugin_select, plugin);
   return 1;
 }
 
@@ -946,15 +942,13 @@ unix_transport_server_start (void *cls)
  *
  */
 static int
-unix_check_address (void *cls,
-                   const void *addr,
-                   size_t addrlen)
+unix_check_address (void *cls, const void *addr, size_t addrlen)
 {
 
 #if DEBUG_UNIX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                   "Informing transport service about my address `%s'\n",
-                   (char *)addr);
+              "Informing transport service about my address `%s'\n",
+              (char *) addr);
 #endif
   return GNUNET_OK;
 }
@@ -970,11 +964,11 @@ append_port (void *cls, const char *hostname)
   char *ret;
 
   if (hostname == NULL)
-    {
-      ppc->asc (ppc->asc_cls, NULL);
-      GNUNET_free (ppc);
-      return;
-    }
+  {
+    ppc->asc (ppc->asc_cls, NULL);
+    GNUNET_free (ppc);
+    return;
+  }
   GNUNET_asprintf (&ret, "%s:%d", hostname, ppc->port);
   ppc->asc (ppc->asc_cls, ret);
   GNUNET_free (ret);
@@ -997,13 +991,13 @@ append_port (void *cls, const char *hostname)
  */
 static void
 unix_plugin_address_pretty_printer (void *cls,
-                                   const char *type,
-                                   const void *addr,
-                                   size_t addrlen,
-                                   int numeric,
-                                   struct GNUNET_TIME_Relative timeout,
-                                   GNUNET_TRANSPORT_AddressStringCallback asc,
-                                   void *asc_cls)
+                                    const char *type,
+                                    const void *addr,
+                                    size_t addrlen,
+                                    int numeric,
+                                    struct GNUNET_TIME_Relative timeout,
+                                    GNUNET_TRANSPORT_AddressStringCallback asc,
+                                    void *asc_cls)
 {
   struct PrettyPrinterContext *ppc;
   const void *sb;
@@ -1015,43 +1009,39 @@ unix_plugin_address_pretty_printer (void *cls,
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6UdpAddress))
-    {
-      u6 = addr;
-      memset (&a6, 0, sizeof (a6));
-      a6.sin6_family = AF_INET6;
-      a6.sin6_port = u6->u6_port;
-      memcpy (&a6.sin6_addr,
-              &u6->ipv6_addr,
-              sizeof (struct in6_addr));
-      port = ntohs (u6->u6_port);
-      sb = &a6;
-      sbs = sizeof (a6);
-    }
+  {
+    u6 = addr;
+    memset (&a6, 0, sizeof (a6));
+    a6.sin6_family = AF_INET6;
+    a6.sin6_port = u6->u6_port;
+    memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof (struct in6_addr));
+    port = ntohs (u6->u6_port);
+    sb = &a6;
+    sbs = sizeof (a6);
+  }
   else if (addrlen == sizeof (struct IPv4UdpAddress))
-    {
-      u4 = addr;
-      memset (&a4, 0, sizeof (a4));
-      a4.sin_family = AF_INET;
-      a4.sin_port = u4->u_port;
-      a4.sin_addr.s_addr = u4->ipv4_addr;
-      port = ntohs (u4->u_port);
-      sb = &a4;
-      sbs = sizeof (a4);
-    }
+  {
+    u4 = addr;
+    memset (&a4, 0, sizeof (a4));
+    a4.sin_family = AF_INET;
+    a4.sin_port = u4->u_port;
+    a4.sin_addr.s_addr = u4->ipv4_addr;
+    port = ntohs (u4->u_port);
+    sb = &a4;
+    sbs = sizeof (a4);
+  }
   else
-    {
-      /* invalid address */
-      GNUNET_break_op (0);
-      asc (asc_cls, NULL);
-      return;
-    }
+  {
+    /* invalid address */
+    GNUNET_break_op (0);
+    asc (asc_cls, NULL);
+    return;
+  }
   ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext));
   ppc->asc = asc;
   ppc->asc_cls = asc_cls;
   ppc->port = port;
-  GNUNET_RESOLVER_hostname_get (sb,
-                                sbs,
-                                !numeric, timeout, &append_port, ppc);
+  GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
 }
 
 /**
@@ -1065,10 +1055,8 @@ unix_plugin_address_pretty_printer (void *cls,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-unix_address_to_string (void *cls,
-                       const void *addr,
-                       size_t addrlen)
+static const char *
+unix_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   if ((addr != NULL) && (addrlen > 0))
     return (const char *) addr;
@@ -1083,14 +1071,14 @@ unix_address_to_string (void *cls,
  * @param tc unused
  */
 static void
-address_notification (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+address_notification (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
-  plugin->env->notify_address(plugin->env->cls,
-                              GNUNET_YES,
-                              plugin->unix_socket_path,
-                              strlen(plugin->unix_socket_path) + 1);
+
+  plugin->env->notify_address (plugin->env->cls,
+                               GNUNET_YES,
+                               plugin->unix_socket_path,
+                               strlen (plugin->unix_socket_path) + 1);
 }
 
 /**
@@ -1108,17 +1096,14 @@ libgnunet_plugin_transport_unix_init (void *cls)
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-unix",
-                                             "PORT",
-                                             &port))
+                                             "transport-unix", "PORT", &port))
     port = UNIX_NAT_DEFAULT_PORT;
   plugin = GNUNET_malloc (sizeof (struct Plugin));
   plugin->port = port;
   plugin->env = env;
-  GNUNET_asprintf (&plugin->unix_socket_path, 
-                   "/tmp/unix-plugin-sock.%d", 
-                   plugin->port);
-  
+  GNUNET_asprintf (&plugin->unix_socket_path,
+                   "/tmp/unix-plugin-sock.%d", plugin->port);
+
   api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
   api->cls = plugin;
 
@@ -1129,10 +1114,9 @@ libgnunet_plugin_transport_unix_init (void *cls)
   api->check_address = &unix_check_address;
   sockets_created = unix_transport_server_start (plugin);
   if (sockets_created == 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to open UNIX sockets\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UNIX sockets\n"));
 
-  GNUNET_SCHEDULER_add_now(address_notification, plugin);
+  GNUNET_SCHEDULER_add_now (address_notification, plugin);
   return api;
 }
 
diff --git a/src/transport/plugin_transport_wlan.c b/src/transport/plugin_transport_wlan.c
index 80b6f2d6f..6ed367293 100644
--- a/src/transport/plugin_transport_wlan.c
+++ b/src/transport/plugin_transport_wlan.c
@@ -96,7 +96,7 @@
 #define DEBUG_wlan_ip_udp_packets_on_air GNUNET_NO
 
 
-#define IEEE80211_ADDR_LEN      6               /* size of 802.11 address */
+#define IEEE80211_ADDR_LEN      6       /* size of 802.11 address */
 
 #define IEEE80211_FC0_VERSION_MASK              0x03
 #define IEEE80211_FC0_VERSION_SHIFT             0
@@ -113,25 +113,25 @@
 struct iph
 {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-  unsigned int ip_hl :4; /* header length */
-  unsigned int ip_v :4; /* version */
+  unsigned int ip_hl:4;         /* header length */
+  unsigned int ip_v:4;          /* version */
 #endif
 #if __BYTE_ORDER == __BIG_ENDIAN
-  unsigned int ip_v:4; /* version */
-  unsigned int ip_hl:4; /* header length */
+  unsigned int ip_v:4;          /* version */
+  unsigned int ip_hl:4;         /* header length */
 #endif
-  u_int8_t ip_tos; /* type of service */
-  u_short ip_len; /* total length */
-  u_short ip_id; /* identification */
-  u_short ip_off; /* fragment offset field */
-#define IP_RF 0x8000                    /* reserved fragment flag */
-#define IP_DF 0x4000                    /* dont fragment flag */
-#define IP_MF 0x2000                    /* more fragments flag */
-#define IP_OFFMASK 0x1fff               /* mask for fragmenting bits */
-  u_int8_t ip_ttl; /* time to live */
-  u_int8_t ip_p; /* protocol */
-  u_short ip_sum; /* checksum */
-  struct in_addr ip_src, ip_dst; /* source and dest address */
+  u_int8_t ip_tos;              /* type of service */
+  u_short ip_len;               /* total length */
+  u_short ip_id;                /* identification */
+  u_short ip_off;               /* fragment offset field */
+#define IP_RF 0x8000            /* reserved fragment flag */
+#define IP_DF 0x4000            /* dont fragment flag */
+#define IP_MF 0x2000            /* more fragments flag */
+#define IP_OFFMASK 0x1fff       /* mask for fragmenting bits */
+  u_int8_t ip_ttl;              /* time to live */
+  u_int8_t ip_p;                /* protocol */
+  u_short ip_sum;               /* checksum */
+  struct in_addr ip_src, ip_dst;        /* source and dest address */
 };
 
 struct udphdr
@@ -154,11 +154,11 @@ struct ieee80211_frame
   u_int8_t i_addr3[IEEE80211_ADDR_LEN];
   u_int8_t i_seq[2];
 #if DEBUG_wlan_ip_udp_packets_on_air
-u_int8_t llc[4];
-struct iph ip;
-struct udphdr udp;
+  u_int8_t llc[4];
+  struct iph ip;
+  struct udphdr udp;
 #endif
-}GNUNET_PACKED;
+} GNUNET_PACKED;
 
 /**
  * Encapsulation of all of the state of the plugin.
@@ -173,12 +173,12 @@ struct Plugin
   /**
    * List of open connections. head
    */
-  struct MacEndpoint * mac_head;
+  struct MacEndpoint *mac_head;
 
   /**
    * List of open connections. tail
    */
-  struct MacEndpoint * mac_tail;
+  struct MacEndpoint *mac_tail;
 
   /**
    * Number of connections
@@ -188,12 +188,12 @@ struct Plugin
   /**
    * encapsulation of data from the local wlan helper program
    */
-  struct GNUNET_SERVER_MessageStreamTokenizer * suid_tokenizer;
+  struct GNUNET_SERVER_MessageStreamTokenizer *suid_tokenizer;
 
   /**
    * encapsulation of packets received from the wlan helper
    */
-  struct GNUNET_SERVER_MessageStreamTokenizer * data_tokenizer;
+  struct GNUNET_SERVER_MessageStreamTokenizer *data_tokenizer;
 
   /**
    * stdout pipe handle for the gnunet-wlan-helper process
@@ -249,13 +249,13 @@ struct Plugin
    * Sessions currently pending for transmission
    * to a peer, if any.
    */
-  struct Sessionqueue * pending_Sessions_head;
+  struct Sessionqueue *pending_Sessions_head;
 
   /**
    * Sessions currently pending for transmission
    * to a peer (tail), if any.
    */
-  struct Sessionqueue * pending_Sessions_tail;
+  struct Sessionqueue *pending_Sessions_tail;
 
   /**
    * number of pending sessions
@@ -270,11 +270,11 @@ struct Plugin
   /**
    * messages ready for send, head
    */
-  struct FragmentMessage_queue * sending_messages_head;
+  struct FragmentMessage_queue *sending_messages_head;
   /**
    * messages ready for send, tail
    */
-  struct FragmentMessage_queue * sending_messages_tail;
+  struct FragmentMessage_queue *sending_messages_tail;
   /**
    * time of the next "hello-beacon"
    */
@@ -283,12 +283,12 @@ struct Plugin
   /**
    * queue to send acks for received fragments (head)
    */
-  struct AckSendQueue * ack_send_queue_head;
+  struct AckSendQueue *ack_send_queue_head;
 
   /**
    * queue to send acks for received fragments (tail)
    */
-  struct AckSendQueue * ack_send_queue_tail;
+  struct AckSendQueue *ack_send_queue_tail;
 
   /**
    * Tracker for bandwidth limit
@@ -301,9 +301,9 @@ struct Plugin
  */
 struct Finish_send
 {
-  struct Plugin * plugin;
-  char * msgheader;
-  struct GNUNET_MessageHeader * msgstart;
+  struct Plugin *plugin;
+  char *msgheader;
+  struct GNUNET_MessageHeader *msgstart;
   ssize_t size;
 };
 
@@ -313,9 +313,9 @@ struct Finish_send
 //TODO DOXIGEN
 struct Sessionqueue
 {
-  struct Sessionqueue * next;
-  struct Sessionqueue * prev;
-  struct Session * content;
+  struct Sessionqueue *next;
+  struct Sessionqueue *prev;
+  struct Session *content;
 };
 
 /**
@@ -324,9 +324,9 @@ struct Sessionqueue
 //TODO DOXIGEN
 struct FragmentMessage_queue
 {
-  struct FragmentMessage_queue * next;
-  struct FragmentMessage_queue * prev;
-  struct FragmentMessage * content;
+  struct FragmentMessage_queue *next;
+  struct FragmentMessage_queue *prev;
+  struct FragmentMessage *content;
 };
 
 /**
@@ -335,10 +335,10 @@ struct FragmentMessage_queue
 //TODO DOXIGEN
 struct Receive_Fragment_Queue
 {
-  struct Receive_Fragment_Queue * next;
-  struct Receive_Fragment_Queue * prev;
+  struct Receive_Fragment_Queue *next;
+  struct Receive_Fragment_Queue *prev;
   uint16_t num;
-  const char * msg;
+  const char *msg;
   uint16_t size;
   struct Radiotap_rx rxinfo;
 };
@@ -346,16 +346,16 @@ struct Receive_Fragment_Queue
 //TODO DOXIGEN
 struct MacEndpoint_id_fragment_triple
 {
-  struct MacEndpoint * endpoint;
+  struct MacEndpoint *endpoint;
   uint32_t message_id;
-  struct FragmentMessage * fm;
+  struct FragmentMessage *fm;
 };
 
 //TODO DOXIGEN
 struct Plugin_Session_pair
 {
-  struct Plugin * plugin;
-  struct Session * session;
+  struct Plugin *plugin;
+  struct Session *session;
 };
 
 /**
@@ -367,11 +367,11 @@ struct PendingMessage
   /**
    * dll next
    */
-  struct PendingMessage * next;
+  struct PendingMessage *next;
   /**
    * dll prev
    */
-  struct PendingMessage * prev;
+  struct PendingMessage *prev;
 
   /**
    * The pending message
@@ -393,7 +393,7 @@ struct PendingMessage
   /**
    * Cls for transmit_cont
    */
-  void * transmit_cont_cls;
+  void *transmit_cont_cls;
 
   /**
    * Timeout value for the pending message.
@@ -411,15 +411,15 @@ struct AckSendQueue
   /**
    * next ack in the ack send queue
    */
-  struct AckSendQueue * next;
+  struct AckSendQueue *next;
   /**
    * previous ack in the ack send queue
    */
-  struct AckSendQueue * prev;
+  struct AckSendQueue *prev;
   /**
    * pointer to the session this ack belongs to
    */
-  struct MacEndpoint * endpoint;
+  struct MacEndpoint *endpoint;
   /**
    * ID of message, to distinguish between the messages, picked randomly.
    */
@@ -428,15 +428,15 @@ struct AckSendQueue
   /**
    * msg to send
    */
-  struct GNUNET_MessageHeader * hdr;
+  struct GNUNET_MessageHeader *hdr;
   /**
    * pointer to the ieee wlan header
    */
-  struct ieee80211_frame * ieeewlanheader;
+  struct ieee80211_frame *ieeewlanheader;
   /**
    * pointer to the radiotap header
    */
-  struct Radiotap_Send * radioHeader;
+  struct Radiotap_Send *radioHeader;
 };
 
 /**
@@ -448,7 +448,7 @@ struct Session_light
   /**
    * the session this message belongs to
    */
-  struct Session * session;
+  struct Session *session;
   /**
    * peer mac address
    */
@@ -457,7 +457,7 @@ struct Session_light
   /**
    * mac endpoint
    */
-  struct MacEndpoint * macendpoint;
+  struct MacEndpoint *macendpoint;
 };
 
 /**
@@ -475,13 +475,13 @@ struct Session
    * Message currently pending for transmission
    * to this peer, if any. head
    */
-  struct PendingMessage * pending_message_head;
+  struct PendingMessage *pending_message_head;
 
   /**
    * Message currently pending for transmission
    * to this peer, if any. tail
    */
-  struct PendingMessage * pending_message_tail;
+  struct PendingMessage *pending_message_tail;
 
   /**
    * To whom are we talking to (set to our identity
@@ -509,7 +509,7 @@ struct Session
   /**
    * peer connection
    */
-  struct MacEndpoint * mac;
+  struct MacEndpoint *mac;
 
   /**
    * count of messages in the fragment out queue for this session
@@ -531,22 +531,22 @@ struct MacEndpoint
   /**
    * Struct to hold the session reachable over this mac; head
    */
-  struct Sessionqueue * sessions_head;
+  struct Sessionqueue *sessions_head;
   /**
    * Struct to hold the session reachable over this mac; tail
    */
-  struct Sessionqueue * sessions_tail;
+  struct Sessionqueue *sessions_tail;
   /**
    * Messages currently sending
    * to a peer, if any.
    */
-  struct FragmentMessage * sending_messages_head;
+  struct FragmentMessage *sending_messages_head;
 
   /**
    * Messages currently sending
    * to a peer (tail), if any.
    */
-  struct FragmentMessage * sending_messages_tail;
+  struct FragmentMessage *sending_messages_tail;
   /**
    * dll next
    */
@@ -564,7 +564,7 @@ struct MacEndpoint
   /**
    * Defrag context for this mac endpoint
    */
-  struct GNUNET_DEFRAGMENT_Context * defrag;
+  struct GNUNET_DEFRAGMENT_Context *defrag;
 
   /**
    * count of messages in the fragment out queue for this mac endpoint
@@ -630,7 +630,7 @@ struct FragmentMessage
   /**
    * Fragmentation context
    */
-  struct GNUNET_FRAGMENT_Context * fragcontext;
+  struct GNUNET_FRAGMENT_Context *fragcontext;
 
   /**
    * Timeout value for the message.
@@ -645,7 +645,7 @@ struct FragmentMessage
   /**
    * Fragment to send
    */
-  char * frag;
+  char *frag;
 
   /**
    * size of message
@@ -655,20 +655,20 @@ struct FragmentMessage
   /**
    * pointer to the ieee wlan header
    */
-  struct ieee80211_frame * ieeewlanheader;
+  struct ieee80211_frame *ieeewlanheader;
   /**
    * pointer to the radiotap header
    */
-  struct Radiotap_Send * radioHeader;
+  struct Radiotap_Send *radioHeader;
 };
 
 static void
-do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+do_transmit (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 static void
-free_session(struct Plugin * plugin, struct Sessionqueue * queue,
-    int do_free_macendpoint);
-static struct MacEndpoint *
-create_macendpoint(struct Plugin *plugin, const struct MacAddress *addr);
+free_session (struct Plugin *plugin, struct Sessionqueue *queue,
+              int do_free_macendpoint);
+static struct MacEndpoint *create_macendpoint (struct Plugin *plugin,
+                                               const struct MacAddress *addr);
 
 /**
  * Generates a nice hexdump of a memory area.
@@ -677,51 +677,50 @@ create_macendpoint(struct Plugin *plugin, const struct MacAddress *addr);
  * \param  length  how many bytes to dump
  */
 void
-hexdump(void *mem, unsigned length)
+hexdump (void *mem, unsigned length)
 {
   char line[80];
-  char *src = (char*) mem;
+  char *src = (char *) mem;
 
-  printf(
-      "dumping %u bytes from %p\r\n"
-        "       0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F    0123456789ABCDEF\r\n",
-      length, src);
+  printf ("dumping %u bytes from %p\r\n"
+          "       0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F    0123456789ABCDEF\r\n",
+          length, src);
   unsigned i;
   int j;
 
   for (i = 0; i < length; i += 16, src += 16)
-    {
-      char *t = line;
+  {
+    char *t = line;
 
-      t += sprintf(t, "%04x:  ", i);
-      for (j = 0; j < 16; j++)
-        {
-          if (i + j < length)
-            t += sprintf(t, "%02X", src[j] & 0xff);
-          else
-            t += sprintf(t, "  ");
-          t += sprintf(t, j % 2 ? " " : "-");
-        }
-
-      t += sprintf(t, "  ");
-      for (j = 0; j < 16; j++)
-        {
-          if (i + j < length)
-            {
-              if (isprint((unsigned char)src[j]))
-                t += sprintf(t, "%c", src[j]);
-              else
-                t += sprintf(t, ".");
-            }
-          else
-            {
-              t += sprintf(t, " ");
-            }
-        }
+    t += sprintf (t, "%04x:  ", i);
+    for (j = 0; j < 16; j++)
+    {
+      if (i + j < length)
+        t += sprintf (t, "%02X", src[j] & 0xff);
+      else
+        t += sprintf (t, "  ");
+      t += sprintf (t, j % 2 ? " " : "-");
+    }
 
-      t += sprintf(t, "\r\n");
-      printf("%s", line);
+    t += sprintf (t, "  ");
+    for (j = 0; j < 16; j++)
+    {
+      if (i + j < length)
+      {
+        if (isprint ((unsigned char) src[j]))
+          t += sprintf (t, "%c", src[j]);
+        else
+          t += sprintf (t, ".");
+      }
+      else
+      {
+        t += sprintf (t, " ");
+      }
     }
+
+    t += sprintf (t, "\r\n");
+    printf ("%s", line);
+  }
 }
 
 /**
@@ -732,28 +731,30 @@ hexdump(void *mem, unsigned length)
  * @return
  */
 static struct MacEndpoint *
-get_macendpoint(struct Plugin *plugin, const struct MacAddress *addr,
-    int create_new)
+get_macendpoint (struct Plugin *plugin, const struct MacAddress *addr,
+                 int create_new)
 {
-  struct MacEndpoint * queue = plugin->mac_head;
+  struct MacEndpoint *queue = plugin->mac_head;
+
   while (queue != NULL)
-    {
-      GNUNET_assert (queue->sessions_head != NULL);
-      if (memcmp(addr, &queue->addr, sizeof(struct MacAddress)) == 0)
-        return queue; /* session found */
-      queue = queue->next;
-    }
+  {
+    GNUNET_assert (queue->sessions_head != NULL);
+    if (memcmp (addr, &queue->addr, sizeof (struct MacAddress)) == 0)
+      return queue;             /* session found */
+    queue = queue->next;
+  }
 
   if (create_new == GNUNET_YES)
-    {
-      return create_macendpoint(plugin, addr);
-    }
+  {
+    return create_macendpoint (plugin, addr);
+  }
   else
-    {
-      return NULL;
-    }
+  {
+    return NULL;
+  }
 
 }
+
 /**
  * search for a session with the addr and peer id
  *
@@ -763,20 +764,20 @@ get_macendpoint(struct Plugin *plugin, const struct MacAddress *addr,
  * @return returns the session
  */
 static struct Session *
-search_session(struct Plugin *plugin, const struct MacEndpoint * endpoint,
-    const struct GNUNET_PeerIdentity * peer)
+search_session (struct Plugin *plugin, const struct MacEndpoint *endpoint,
+                const struct GNUNET_PeerIdentity *peer)
 {
-  GNUNET_assert(endpoint != NULL);
-  struct Sessionqueue * queue = endpoint->sessions_head;
+  GNUNET_assert (endpoint != NULL);
+  struct Sessionqueue *queue = endpoint->sessions_head;
 
   while (queue != NULL)
-    {
-      GNUNET_assert (queue->content != NULL);
-      if (memcmp(peer, &queue->content->target,
-          sizeof(struct GNUNET_PeerIdentity)) == 0)
-        return queue->content; /* session found */
-      queue = queue->next;
-    }
+  {
+    GNUNET_assert (queue->content != NULL);
+    if (memcmp (peer, &queue->content->target,
+                sizeof (struct GNUNET_PeerIdentity)) == 0)
+      return queue->content;    /* session found */
+    queue = queue->next;
+  }
   return NULL;
 }
 
@@ -791,21 +792,21 @@ search_session(struct Plugin *plugin, const struct MacEndpoint * endpoint,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen)
+static const char *
+wlan_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   static char ret[40];
   const struct MacAddress *mac;
 
-  if (addrlen != sizeof(struct MacAddress))
-    {
-      GNUNET_break (0);
-      return NULL;
-    }
+  if (addrlen != sizeof (struct MacAddress))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   mac = addr;
-  GNUNET_snprintf(ret, sizeof(ret), "%s Mac-Address %X:%X:%X:%X:%X:%X",
-      PROTOCOL_PREFIX, mac->mac[0], mac->mac[1], mac->mac[2], mac->mac[3],
-      mac->mac[4], mac->mac[5]);
+  GNUNET_snprintf (ret, sizeof (ret), "%s Mac-Address %X:%X:%X:%X:%X:%X",
+                   PROTOCOL_PREFIX, mac->mac[0], mac->mac[1], mac->mac[2],
+                   mac->mac[3], mac->mac[4], mac->mac[5]);
   return ret;
 }
 
@@ -815,25 +816,27 @@ wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen)
  * @param tc pointer to the GNUNET_SCHEDULER_TaskContext
  */
 static void
-session_timeout (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc){
-  struct Sessionqueue * queue = cls;
-  GNUNET_assert(queue != NULL);
+session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct Sessionqueue *queue = cls;
+
+  GNUNET_assert (queue != NULL);
   queue->content->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN){
-      return;
+  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+  {
+    return;
+  }
+  if (GNUNET_TIME_absolute_get_remaining
+      (GNUNET_TIME_absolute_add
+       (queue->content->last_activity, SESSION_TIMEOUT)).rel_value == 0)
+  {
+    free_session (queue->content->mac->plugin, queue, GNUNET_YES);
   }
-  if (GNUNET_TIME_absolute_get_remaining(
-      GNUNET_TIME_absolute_add(queue->content->last_activity, SESSION_TIMEOUT)).rel_value
-      == 0)
-    {
-      free_session(queue->content->mac->plugin,queue,GNUNET_YES);
-    }
   else
-    {
-      queue->content->timeout_task = GNUNET_SCHEDULER_add_delayed(SESSION_TIMEOUT,
-          &session_timeout, queue);
-    }
+  {
+    queue->content->timeout_task =
+        GNUNET_SCHEDULER_add_delayed (SESSION_TIMEOUT, &session_timeout, queue);
+  }
 }
 
 /**
@@ -845,24 +848,29 @@ session_timeout (void *cls,
  */
 
 static struct Session *
-create_session(struct Plugin *plugin, struct MacEndpoint * endpoint,
-    const struct GNUNET_PeerIdentity * peer)
+create_session (struct Plugin *plugin, struct MacEndpoint *endpoint,
+                const struct GNUNET_PeerIdentity *peer)
 {
-  GNUNET_assert(endpoint != NULL);
-  struct Sessionqueue * queue = GNUNET_malloc (sizeof (struct Sessionqueue) + sizeof (struct Session));
+  GNUNET_assert (endpoint != NULL);
+  struct Sessionqueue *queue =
+      GNUNET_malloc (sizeof (struct Sessionqueue) + sizeof (struct Session));
 
-  GNUNET_CONTAINER_DLL_insert_tail(endpoint->sessions_head, endpoint->sessions_tail, queue);
+  GNUNET_CONTAINER_DLL_insert_tail (endpoint->sessions_head,
+                                    endpoint->sessions_tail, queue);
 
   queue->content = (struct Session *) &queue[1];
   queue->content->mac = endpoint;
-  memcpy(&(queue->content->target), peer, sizeof(struct GNUNET_PeerIdentity));
-  queue->content->last_activity = GNUNET_TIME_absolute_get();
-  queue->content->timeout_task = GNUNET_SCHEDULER_add_delayed(SESSION_TIMEOUT,&session_timeout, queue);
+  memcpy (&(queue->content->target), peer, sizeof (struct GNUNET_PeerIdentity));
+  queue->content->last_activity = GNUNET_TIME_absolute_get ();
+  queue->content->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (SESSION_TIMEOUT, &session_timeout, queue);
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "New session %p with endpoint %p: %s\n",
-      queue->content, endpoint,
-      wlan_plugin_address_to_string(NULL, endpoint->addr.mac, 6));
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "New session %p with endpoint %p: %s\n", queue->content,
+                   endpoint, wlan_plugin_address_to_string (NULL,
+                                                            endpoint->addr.mac,
+                                                            6));
 #endif
 
   return queue->content;
@@ -877,16 +885,17 @@ create_session(struct Plugin *plugin, struct MacEndpoint * endpoint,
  * @return returns the session
  */
 static struct Session *
-get_session(struct Plugin *plugin, const struct MacAddress *addr,
-    const struct GNUNET_PeerIdentity * peer)
+get_session (struct Plugin *plugin, const struct MacAddress *addr,
+             const struct GNUNET_PeerIdentity *peer)
 {
-  struct MacEndpoint * mac;
-  mac = get_macendpoint(plugin, addr, GNUNET_YES);
-  struct Session * session = search_session(plugin, mac, peer);
+  struct MacEndpoint *mac;
+
+  mac = get_macendpoint (plugin, addr, GNUNET_YES);
+  struct Session *session = search_session (plugin, mac, peer);
 
   if (session != NULL)
     return session;
-  return create_session(plugin, mac, peer);
+  return create_session (plugin, mac, peer);
 }
 
 /**
@@ -897,35 +906,35 @@ get_session(struct Plugin *plugin, const struct MacAddress *addr,
  * @param session pointer to the session to add
  */
 static void
-queue_session(struct Plugin *plugin, struct Session * session)
+queue_session (struct Plugin *plugin, struct Session *session)
 {
-  struct Sessionqueue * queue = plugin->pending_Sessions_head;
+  struct Sessionqueue *queue = plugin->pending_Sessions_head;
 
   if (session->pending_message_head != NULL)
+  {
+    while (queue != NULL)
     {
-      while (queue != NULL)
-        {
-          // content is never NULL
-          GNUNET_assert (queue->content != NULL);
-          // is session already in queue?
-          if (session == queue->content)
-            {
-              return;
-            }
-          // try next
-          queue = queue->next;
-        }
+      // content is never NULL
+      GNUNET_assert (queue->content != NULL);
+      // is session already in queue?
+      if (session == queue->content)
+      {
+        return;
+      }
+      // try next
+      queue = queue->next;
+    }
 
-      // Session is not in the queue
+    // Session is not in the queue
 
-      queue = GNUNET_malloc (sizeof (struct Sessionqueue));
-      queue->content = session;
+    queue = GNUNET_malloc (sizeof (struct Sessionqueue));
+    queue->content = session;
 
-      //insert at the tail
-      GNUNET_CONTAINER_DLL_insert_tail(plugin->pending_Sessions_head,
-          plugin->pending_Sessions_tail, queue);
-      plugin->pendingsessions++;
-    }
+    //insert at the tail
+    GNUNET_CONTAINER_DLL_insert_tail (plugin->pending_Sessions_head,
+                                      plugin->pending_Sessions_tail, queue);
+    plugin->pendingsessions++;
+  }
 
 }
 
@@ -935,9 +944,10 @@ queue_session(struct Plugin *plugin, struct Session * session)
  * @param tc GNUNET_SCHEDULER_TaskContext pointer
  */
 static void
-delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+delay_fragment_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct Plugin * plugin = cls;
+  struct Plugin *plugin = cls;
+
   plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
@@ -945,11 +955,12 @@ delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   // GNUNET_TIME_UNIT_FOREVER_REL is needed to clean up old msg
   if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK)
-    {
-      plugin->server_write_task = GNUNET_SCHEDULER_add_write_file(
-          GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle,
-          &do_transmit, plugin);
-    }
+  {
+    plugin->server_write_task =
+        GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                         plugin->server_stdin_handle,
+                                         &do_transmit, plugin);
+  }
 }
 
 /**
@@ -958,32 +969,33 @@ delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 
 static void
-set_next_beacon_time(struct Plugin * const plugin)
+set_next_beacon_time (struct Plugin *const plugin)
 {
   //under 10 known peers: once a second
   if (plugin->mac_count < 10)
-    {
-      plugin->beacon_time = GNUNET_TIME_absolute_add(
-          GNUNET_TIME_absolute_get(),
-          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-              HALLO_BEACON_SCALING_FACTOR));
-    }
+  {
+    plugin->beacon_time = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
+                                                    GNUNET_TIME_relative_multiply
+                                                    (GNUNET_TIME_UNIT_SECONDS,
+                                                     HALLO_BEACON_SCALING_FACTOR));
+  }
   //under 30 known peers: every 10 seconds
   else if (plugin->mac_count < 30)
-    {
-      plugin->beacon_time = GNUNET_TIME_absolute_add(
-          GNUNET_TIME_absolute_get(),
-          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-              10 * HALLO_BEACON_SCALING_FACTOR));
-    }
+  {
+    plugin->beacon_time = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
+                                                    GNUNET_TIME_relative_multiply
+                                                    (GNUNET_TIME_UNIT_SECONDS,
+                                                     10 *
+                                                     HALLO_BEACON_SCALING_FACTOR));
+  }
   //over 30 known peers: once a minute
   else
-    {
-      plugin->beacon_time = GNUNET_TIME_absolute_add(
-          GNUNET_TIME_absolute_get(),
-          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES,
-              HALLO_BEACON_SCALING_FACTOR));
-    }
+  {
+    plugin->beacon_time = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
+                                                    GNUNET_TIME_relative_multiply
+                                                    (GNUNET_TIME_UNIT_MINUTES,
+                                                     HALLO_BEACON_SCALING_FACTOR));
+  }
 }
 
 /**
@@ -992,55 +1004,57 @@ set_next_beacon_time(struct Plugin * const plugin)
  */
 
 static void
-set_next_send(struct Plugin * const plugin)
+set_next_send (struct Plugin *const plugin)
 {
   struct GNUNET_TIME_Relative next_send;
 
   //cancel old task
   if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->server_write_delay_task);
-      plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (plugin->server_write_delay_task);
+    plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK;
+  }
 
   //check if some acks are in the queue
   if (plugin->ack_send_queue_head != NULL)
-    {
-      next_send = GNUNET_TIME_UNIT_ZERO;
-    }
+  {
+    next_send = GNUNET_TIME_UNIT_ZERO;
+  }
 
   //check if there are some fragments in the queue
   else if (plugin->sending_messages_head != NULL)
-    {
-      next_send = GNUNET_TIME_UNIT_ZERO;
-    }
+  {
+    next_send = GNUNET_TIME_UNIT_ZERO;
+  }
   else
-    {
-      next_send = GNUNET_TIME_absolute_get_remaining(plugin->beacon_time);
-    }
+  {
+    next_send = GNUNET_TIME_absolute_get_remaining (plugin->beacon_time);
+  }
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Next packet is send in: %u\n",
-      next_send.rel_value);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Next packet is send in: %u\n", next_send.rel_value);
 #endif
 
   if (next_send.rel_value == GNUNET_TIME_UNIT_ZERO.rel_value)
+  {
+    if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK)
     {
-      if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK)
-        {
-          plugin->server_write_task = GNUNET_SCHEDULER_add_write_file(
-              GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle,
-              &do_transmit, plugin);
-        }
+      plugin->server_write_task =
+          GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                           plugin->server_stdin_handle,
+                                           &do_transmit, plugin);
     }
+  }
   else
+  {
+    if (plugin->server_write_delay_task == GNUNET_SCHEDULER_NO_TASK)
     {
-      if (plugin->server_write_delay_task == GNUNET_SCHEDULER_NO_TASK)
-        {
-          plugin->server_write_delay_task = GNUNET_SCHEDULER_add_delayed(
-              next_send, &delay_fragment_task, plugin);
-        }
+      plugin->server_write_delay_task =
+          GNUNET_SCHEDULER_add_delayed (next_send, &delay_fragment_task,
+                                        plugin);
     }
+  }
 }
 
 /**
@@ -1049,77 +1063,81 @@ set_next_send(struct Plugin * const plugin)
  * @return pointer to the session found, returns NULL if there is now session in the queue
  */
 static struct Session *
-get_next_queue_session(struct Plugin * plugin)
+get_next_queue_session (struct Plugin *plugin)
 {
-  struct Session * session;
-  struct Sessionqueue * sessionqueue;
-  struct Sessionqueue * sessionqueue_alt;
-  struct PendingMessage * pm;
+  struct Session *session;
+  struct Sessionqueue *sessionqueue;
+  struct Sessionqueue *sessionqueue_alt;
+  struct PendingMessage *pm;
+
   sessionqueue = plugin->pending_Sessions_head;
 
   while (sessionqueue != NULL)
-    {
-      session = sessionqueue->content;
+  {
+    session = sessionqueue->content;
 
-      GNUNET_assert(session != NULL);
-      pm = session->pending_message_head;
+    GNUNET_assert (session != NULL);
+    pm = session->pending_message_head;
 
 #if DEBUG_wlan
-      if (pm == NULL)
-        {
-          GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
-              "pending message is empty, should not happen. session %p\n",
-              session);
-        }
+    if (pm == NULL)
+    {
+      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
+                       "pending message is empty, should not happen. session %p\n",
+                       session);
+    }
 #endif
 
-      GNUNET_assert(pm != NULL);
+    GNUNET_assert (pm != NULL);
 
-      //check for message timeout
-      if (GNUNET_TIME_absolute_get_remaining(pm->timeout).rel_value > 0)
-        {
-          //check if session has no message in the fragment queue
-          if ((session->mac->fragment_messages_out_count
-              < FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT)
-              && (session->fragment_messages_out_count
-                  < FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION))
-            {
-              plugin->pendingsessions--;
-              GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head,
-                  plugin->pending_Sessions_tail, sessionqueue);
-              GNUNET_free(sessionqueue);
-
-              return session;
-            }
-          else
-            {
-              sessionqueue = sessionqueue->next;
-            }
-        }
+    //check for message timeout
+    if (GNUNET_TIME_absolute_get_remaining (pm->timeout).rel_value > 0)
+    {
+      //check if session has no message in the fragment queue
+      if ((session->mac->fragment_messages_out_count
+           < FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT)
+          && (session->fragment_messages_out_count
+              < FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION))
+      {
+        plugin->pendingsessions--;
+        GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head,
+                                     plugin->pending_Sessions_tail,
+                                     sessionqueue);
+        GNUNET_free (sessionqueue);
+
+        return session;
+      }
       else
-        {
-          GNUNET_CONTAINER_DLL_remove(session->pending_message_head, session->pending_message_tail, pm);
-
-          //call the cont func that it did not work
-          if (pm->transmit_cont != NULL)
-            pm->transmit_cont(pm->transmit_cont_cls, &(session->target),
-                GNUNET_SYSERR);
-          GNUNET_free(pm->msg);
-          GNUNET_free(pm);
-
-          if (session->pending_message_head == NULL)
-            {
-              sessionqueue_alt = sessionqueue;
-              sessionqueue = sessionqueue->next;
-              plugin->pendingsessions--;
-              GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head,
-                  plugin->pending_Sessions_tail, sessionqueue_alt);
-
-              GNUNET_free(sessionqueue_alt);
-            }
-        }
+      {
+        sessionqueue = sessionqueue->next;
+      }
+    }
+    else
+    {
+      GNUNET_CONTAINER_DLL_remove (session->pending_message_head,
+                                   session->pending_message_tail, pm);
 
+      //call the cont func that it did not work
+      if (pm->transmit_cont != NULL)
+        pm->transmit_cont (pm->transmit_cont_cls, &(session->target),
+                           GNUNET_SYSERR);
+      GNUNET_free (pm->msg);
+      GNUNET_free (pm);
+
+      if (session->pending_message_head == NULL)
+      {
+        sessionqueue_alt = sessionqueue;
+        sessionqueue = sessionqueue->next;
+        plugin->pendingsessions--;
+        GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head,
+                                     plugin->pending_Sessions_tail,
+                                     sessionqueue_alt);
+
+        GNUNET_free (sessionqueue_alt);
+      }
     }
+
+  }
   return NULL;
 }
 
@@ -1129,42 +1147,45 @@ get_next_queue_session(struct Plugin * plugin)
  * @param fm message to free
  */
 static void
-free_fragment_message(struct Plugin * plugin, struct FragmentMessage * fm)
+free_fragment_message (struct Plugin *plugin, struct FragmentMessage *fm)
 {
-  struct Session * session = fm->session;
-  struct MacEndpoint * endpoint = session->mac;
-  struct FragmentMessage_queue * fmq;
-  struct FragmentMessage_queue * fmq_next;
+  struct Session *session = fm->session;
+  struct MacEndpoint *endpoint = session->mac;
+  struct FragmentMessage_queue *fmq;
+  struct FragmentMessage_queue *fmq_next;
 
   if (fm != NULL)
+  {
+    fmq = plugin->sending_messages_head;
+    while (fmq != NULL)
     {
-      fmq = plugin->sending_messages_head;
-      while (fmq != NULL)
-        {
-          fmq_next = fmq->next;
-          if (fmq->content == fm)
-            {
-              GNUNET_CONTAINER_DLL_remove(plugin->sending_messages_head,plugin->sending_messages_tail, fmq);
-              GNUNET_free(fmq);
-            }
-          fmq = fmq_next;
-        }
-
-      (session->mac->fragment_messages_out_count)--;
-      session->fragment_messages_out_count--;
-      plugin->pending_Fragment_Messages--;
-      GNUNET_CONTAINER_DLL_remove(endpoint->sending_messages_head,endpoint->sending_messages_tail, fm);
-      GNUNET_FRAGMENT_context_destroy(fm->fragcontext);
-      if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel(fm->timeout_task);
-      GNUNET_free(fm);
+      fmq_next = fmq->next;
+      if (fmq->content == fm)
+      {
+        GNUNET_CONTAINER_DLL_remove (plugin->sending_messages_head,
+                                     plugin->sending_messages_tail, fmq);
+        GNUNET_free (fmq);
+      }
+      fmq = fmq_next;
+    }
 
-      queue_session(plugin, session);
+    (session->mac->fragment_messages_out_count)--;
+    session->fragment_messages_out_count--;
+    plugin->pending_Fragment_Messages--;
+    GNUNET_CONTAINER_DLL_remove (endpoint->sending_messages_head,
+                                 endpoint->sending_messages_tail, fm);
+    GNUNET_FRAGMENT_context_destroy (fm->fragcontext);
+    if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (fm->timeout_task);
+    GNUNET_free (fm);
+
+    queue_session (plugin, session);
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Free pending fragment messages %p, session %p\n", fm, session);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Free pending fragment messages %p, session %p\n", fm,
+                     session);
 #endif
-    }
+  }
 }
 
 /**
@@ -1175,22 +1196,22 @@ free_fragment_message(struct Plugin * plugin, struct FragmentMessage * fm)
  * @return GNUNET_YES at success
  */
 static int
-getRadiotapHeader(struct Plugin * plugin, struct MacEndpoint * endpoint,
-    struct Radiotap_Send * header)
+getRadiotapHeader (struct Plugin *plugin, struct MacEndpoint *endpoint,
+                   struct Radiotap_Send *header)
 {
 
   if (endpoint != NULL)
-    {
-      header->rate = endpoint->rate;
-      header->tx_power = endpoint->tx_power;
-      header->antenna = endpoint->antenna;
-    }
+  {
+    header->rate = endpoint->rate;
+    header->tx_power = endpoint->tx_power;
+    header->antenna = endpoint->antenna;
+  }
   else
-    {
-      header->rate = 255;
-      header->tx_power = 0;
-      header->antenna = 0;
-    }
+  {
+    header->rate = 255;
+    header->tx_power = 0;
+    header->antenna = 0;
+  }
 
   return GNUNET_YES;
 }
@@ -1203,50 +1224,52 @@ getRadiotapHeader(struct Plugin * plugin, struct MacEndpoint * endpoint,
  * @return GNUNET_YES if there was no error
  */
 static int
-getWlanHeader(struct ieee80211_frame * Header,
-    const struct MacAddress * to_mac_addr, struct Plugin * plugin,
-    unsigned int size)
+getWlanHeader (struct ieee80211_frame *Header,
+               const struct MacAddress *to_mac_addr, struct Plugin *plugin,
+               unsigned int size)
 {
-  uint16_t * tmp16;
+  uint16_t *tmp16;
   const int rate = 11000000;
 
   Header->i_fc[0] = IEEE80211_FC0_TYPE_DATA;
   Header->i_fc[1] = 0x00;
-  memcpy(&Header->i_addr3, &mac_bssid, sizeof(mac_bssid));
-  memcpy(&Header->i_addr2, plugin->mac_address.mac, sizeof(plugin->mac_address));
-  memcpy(&Header->i_addr1, to_mac_addr, sizeof(struct MacAddress));
+  memcpy (&Header->i_addr3, &mac_bssid, sizeof (mac_bssid));
+  memcpy (&Header->i_addr2, plugin->mac_address.mac,
+          sizeof (plugin->mac_address));
+  memcpy (&Header->i_addr1, to_mac_addr, sizeof (struct MacAddress));
 
-  tmp16 = (uint16_t*) Header->i_dur;
-  *tmp16 = (uint16_t) htole16((size * 1000000) / rate + 290);
+  tmp16 = (uint16_t *) Header->i_dur;
+  *tmp16 = (uint16_t) htole16 ((size * 1000000) / rate + 290);
 
 #if DEBUG_wlan_ip_udp_packets_on_air
   uint crc = 0;
-  uint16_t * x;
+  uint16_t *x;
   int count;
-  Header->ip.ip_dst.s_addr = *((uint32_t*) &to_mac_addr->mac[2]);
-  Header->ip.ip_src.s_addr = *((uint32_t*) &plugin->mac_address.mac[2]);
+
+  Header->ip.ip_dst.s_addr = *((uint32_t *) & to_mac_addr->mac[2]);
+  Header->ip.ip_src.s_addr = *((uint32_t *) & plugin->mac_address.mac[2]);
   Header->ip.ip_v = 4;
   Header->ip.ip_hl = 5;
   Header->ip.ip_p = 17;
   Header->ip.ip_ttl = 1;
-  Header->ip.ip_len = htons(size + 8);
+  Header->ip.ip_len = htons (size + 8);
   Header->ip.ip_sum = 0;
-  x =(uint16_t *) &Header->ip;
-  count = sizeof(struct iph);
+  x = (uint16_t *) & Header->ip;
+  count = sizeof (struct iph);
   while (count > 1)
-    {
-      /* This is the inner loop */
-      crc += (unsigned short) * x++;
-      count -= 2;
-    }
+  {
+    /* This is the inner loop */
+    crc += (unsigned short) *x++;
+    count -= 2;
+  }
   /* Add left-over byte, if any */
-  if( count > 0 )
-  crc += * (unsigned char *) x;
+  if (count > 0)
+    crc += *(unsigned char *) x;
   crc = (crc & 0xffff) + (crc >> 16);
-  Header->ip.ip_sum = htons(~ (unsigned short) crc);
+  Header->ip.ip_sum = htons (~(unsigned short) crc);
   Header->llc[0] = 6;
   Header->llc[1] = 6;
-  Header->udp.len = htons(size - sizeof(struct ieee80211_frame));
+  Header->udp.len = htons (size - sizeof (struct ieee80211_frame));
 
 #endif
 
@@ -1263,10 +1286,10 @@ getWlanHeader(struct ieee80211_frame * Header,
  */
 
 uint32_t
-getcrc32(const char *msgbuf, size_t msgbuf_size)
+getcrc32 (const char *msgbuf, size_t msgbuf_size)
 {
 
-  return GNUNET_CRYPTO_crc32_n(msgbuf, msgbuf_size);;
+  return GNUNET_CRYPTO_crc32_n (msgbuf, msgbuf_size);;
 }
 
 /**
@@ -1279,7 +1302,7 @@ getcrc32(const char *msgbuf, size_t msgbuf_size)
  */
 
 uint16_t
-getcrc16(const char *msgbuf, size_t msgbuf_size)
+getcrc16 (const char *msgbuf, size_t msgbuf_size)
 {
   //TODO calc some crc
   return 0;
@@ -1292,46 +1315,46 @@ getcrc16(const char *msgbuf, size_t msgbuf_size)
  */
 
 void
-add_message_for_send(void *cls, const struct GNUNET_MessageHeader *hdr)
+add_message_for_send (void *cls, const struct GNUNET_MessageHeader *hdr)
 {
 
-  struct FragmentMessage * fm = cls;
-  struct FragmentMessage_queue * fmqueue;
+  struct FragmentMessage *fm = cls;
+  struct FragmentMessage_queue *fmqueue;
 
-  GNUNET_assert(cls != NULL);
-  GNUNET_assert(fm->frag == NULL);
-  struct MacEndpoint * endpoint = fm->session->mac;
-  struct Plugin * plugin = endpoint->plugin;
-  struct GNUNET_MessageHeader * msgheader;
-  struct GNUNET_MessageHeader * msgheader2;
+  GNUNET_assert (cls != NULL);
+  GNUNET_assert (fm->frag == NULL);
+  struct MacEndpoint *endpoint = fm->session->mac;
+  struct Plugin *plugin = endpoint->plugin;
+  struct GNUNET_MessageHeader *msgheader;
+  struct GNUNET_MessageHeader *msgheader2;
   uint16_t size;
 
 #if DEBUG_wlan_retransmission
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "Adding fragment of message %p to send, session %p, endpoint %p\n", fm,
-      fm->session, endpoint);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Adding fragment of message %p to send, session %p, endpoint %p\n",
+                   fm, fm->session, endpoint);
 #endif
 
-  size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send)
-      + sizeof(struct ieee80211_frame) + ntohs(hdr->size);
-  fm->frag = GNUNET_malloc(size);
+  size = sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send)
+      + sizeof (struct ieee80211_frame) + ntohs (hdr->size);
+  fm->frag = GNUNET_malloc (size);
   fm->size = size;
 
   msgheader = (struct GNUNET_MessageHeader *) fm->frag;
-  msgheader->size = htons(size);
-  msgheader->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
+  msgheader->size = htons (size);
+  msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
 
-  fm->radioHeader = (struct Radiotap_Send*) &msgheader[1];
-  fm->ieeewlanheader = (struct ieee80211_frame*) &fm->radioHeader[1];
-  msgheader2 = (struct GNUNET_MessageHeader*) &fm->ieeewlanheader[1];
-  memcpy(msgheader2, hdr, ntohs(hdr->size));
+  fm->radioHeader = (struct Radiotap_Send *) &msgheader[1];
+  fm->ieeewlanheader = (struct ieee80211_frame *) &fm->radioHeader[1];
+  msgheader2 = (struct GNUNET_MessageHeader *) &fm->ieeewlanheader[1];
+  memcpy (msgheader2, hdr, ntohs (hdr->size));
 
-  fmqueue = GNUNET_malloc(sizeof(struct FragmentMessage_queue));
+  fmqueue = GNUNET_malloc (sizeof (struct FragmentMessage_queue));
   fmqueue->content = fm;
 
-  GNUNET_CONTAINER_DLL_insert_tail(plugin->sending_messages_head,
-      plugin->sending_messages_tail, fmqueue);
-  set_next_send(plugin);
+  GNUNET_CONTAINER_DLL_insert_tail (plugin->sending_messages_head,
+                                    plugin->sending_messages_tail, fmqueue);
+  set_next_send (plugin);
 }
 
 /**
@@ -1339,60 +1362,63 @@ add_message_for_send(void *cls, const struct GNUNET_MessageHeader *hdr)
  * @param plugin pointer to the plugin struct
  */
 static void
-send_hello_beacon(struct Plugin * plugin)
+send_hello_beacon (struct Plugin *plugin)
 {
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,  "Sending hello beacon\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Sending hello beacon\n");
 #endif
 
   uint16_t size;
   ssize_t bytes;
   uint16_t hallo_size;
-  struct GNUNET_MessageHeader * msgheader;
-  struct ieee80211_frame * ieeewlanheader;
-  struct Radiotap_Send * radioHeader;
-  struct GNUNET_MessageHeader * msgheader2;
+  struct GNUNET_MessageHeader *msgheader;
+  struct ieee80211_frame *ieeewlanheader;
+  struct Radiotap_Send *radioHeader;
+  struct GNUNET_MessageHeader *msgheader2;
   const struct GNUNET_MessageHeader *hello;
 
   hello = plugin->env->get_our_hello ();
-  hallo_size = GNUNET_HELLO_size((struct GNUNET_HELLO_Message*)hello);
-  GNUNET_assert(sizeof(struct WlanHeader) + hallo_size <= WLAN_MTU);
-  size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send)
-      + sizeof(struct ieee80211_frame) + sizeof(struct GNUNET_MessageHeader)
+  hallo_size = GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello);
+  GNUNET_assert (sizeof (struct WlanHeader) + hallo_size <= WLAN_MTU);
+  size = sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send)
+      + sizeof (struct ieee80211_frame) + sizeof (struct GNUNET_MessageHeader)
       + hallo_size;
 
-  msgheader = GNUNET_malloc(size);
-  msgheader->size = htons(size);
-  msgheader->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
+  msgheader = GNUNET_malloc (size);
+  msgheader->size = htons (size);
+  msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
 
-  radioHeader = (struct Radiotap_Send*) &msgheader[1];
-  getRadiotapHeader(plugin, NULL, radioHeader);
-  ieeewlanheader = (struct ieee80211_frame*) &radioHeader[1];
-  getWlanHeader(ieeewlanheader, &bc_all_mac, plugin, size);
+  radioHeader = (struct Radiotap_Send *) &msgheader[1];
+  getRadiotapHeader (plugin, NULL, radioHeader);
+  ieeewlanheader = (struct ieee80211_frame *) &radioHeader[1];
+  getWlanHeader (ieeewlanheader, &bc_all_mac, plugin, size);
 
-  msgheader2 = (struct GNUNET_MessageHeader*) &ieeewlanheader[1];
-  msgheader2->size = htons(GNUNET_HELLO_size((struct GNUNET_HELLO_Message*)hello)
-          + sizeof(struct GNUNET_MessageHeader));
+  msgheader2 = (struct GNUNET_MessageHeader *) &ieeewlanheader[1];
+  msgheader2->size =
+      htons (GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello) +
+             sizeof (struct GNUNET_MessageHeader));
 
-  msgheader2->type = htons(GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT);
-  memcpy(&msgheader2[1], hello, hallo_size);
+  msgheader2->type = htons (GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT);
+  memcpy (&msgheader2[1], hello, hallo_size);
 
-  bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, msgheader, size);
+  bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle, msgheader, size);
 
   if (bytes == GNUNET_SYSERR)
-    {
-      GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
-          _("Error writing to wlan healper. errno == %d, ERROR: %s\n"),
-          errno, strerror(errno));
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
+                     _
+                     ("Error writing to wlan healper. errno == %d, ERROR: %s\n"),
+                     errno, strerror (errno));
 
-    }
-  GNUNET_assert(bytes != GNUNET_SYSERR);
-  GNUNET_assert(bytes == size);
-  GNUNET_free(msgheader);
+  }
+  GNUNET_assert (bytes != GNUNET_SYSERR);
+  GNUNET_assert (bytes == size);
+  GNUNET_free (msgheader);
 
-  set_next_beacon_time(plugin);
-  set_next_send(plugin);
+  set_next_beacon_time (plugin);
+  set_next_send (plugin);
 }
 
 /**
@@ -1404,50 +1430,50 @@ send_hello_beacon(struct Plugin * plugin)
  */
 
 static void
-add_ack_for_send(void *cls, uint32_t msg_id,
-    const struct GNUNET_MessageHeader *hdr)
+add_ack_for_send (void *cls, uint32_t msg_id,
+                  const struct GNUNET_MessageHeader *hdr)
 {
 
-  struct AckSendQueue * ack;
+  struct AckSendQueue *ack;
 
-  GNUNET_assert(cls != NULL);
-  struct MacEndpoint * endpoint = cls;
-  struct Plugin * plugin = endpoint->plugin;
-  struct GNUNET_MessageHeader * msgheader;
-  struct GNUNET_MessageHeader * msgheader2;
+  GNUNET_assert (cls != NULL);
+  struct MacEndpoint *endpoint = cls;
+  struct Plugin *plugin = endpoint->plugin;
+  struct GNUNET_MessageHeader *msgheader;
+  struct GNUNET_MessageHeader *msgheader2;
   uint16_t size;
 
-  size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send)
-      + sizeof(struct ieee80211_frame) + ntohs(hdr->size)
-      + sizeof(struct AckSendQueue);
+  size = sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send)
+      + sizeof (struct ieee80211_frame) + ntohs (hdr->size)
+      + sizeof (struct AckSendQueue);
 
-  ack = GNUNET_malloc(size);
+  ack = GNUNET_malloc (size);
   ack->message_id = msg_id;
   ack->endpoint = endpoint;
 
-  size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send)
-      + sizeof(struct ieee80211_frame) + ntohs(hdr->size);
+  size = sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send)
+      + sizeof (struct ieee80211_frame) + ntohs (hdr->size);
 
   msgheader = (struct GNUNET_MessageHeader *) &ack[1];
   ack->hdr = (struct GNUNET_MessageHeader *) &ack[1];
-  msgheader->size = htons(size);
-  msgheader->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
+  msgheader->size = htons (size);
+  msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
 
-  ack->radioHeader = (struct Radiotap_Send*) &msgheader[1];
-  ack->ieeewlanheader = (struct ieee80211_frame*) &(ack->radioHeader)[1];
-  msgheader2 = (struct GNUNET_MessageHeader*) &(ack->ieeewlanheader)[1];
-  memcpy(msgheader2, hdr, ntohs(hdr->size));
+  ack->radioHeader = (struct Radiotap_Send *) &msgheader[1];
+  ack->ieeewlanheader = (struct ieee80211_frame *) &(ack->radioHeader)[1];
+  msgheader2 = (struct GNUNET_MessageHeader *) &(ack->ieeewlanheader)[1];
+  memcpy (msgheader2, hdr, ntohs (hdr->size));
 
-  GNUNET_CONTAINER_DLL_insert_tail(plugin->ack_send_queue_head,
-      plugin->ack_send_queue_tail, ack);
+  GNUNET_CONTAINER_DLL_insert_tail (plugin->ack_send_queue_head,
+                                    plugin->ack_send_queue_tail, ack);
 
 #if DEBUG_wlan_retransmission
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "Adding ack with message id %u to send, AckSendQueue %p, endpoint %p\n",
-      msg_id, ack, endpoint);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Adding ack with message id %u to send, AckSendQueue %p, endpoint %p\n",
+                   msg_id, ack, endpoint);
 #endif
 
-  set_next_send(plugin);
+  set_next_send (plugin);
 }
 
 /**
@@ -1457,14 +1483,17 @@ add_ack_for_send(void *cls, uint32_t msg_id,
  */
 static void
 fragmentmessage_timeout (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc){
-  struct FragmentMessage * fm = cls;
-  GNUNET_assert(fm != NULL);
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct FragmentMessage *fm = cls;
+
+  GNUNET_assert (fm != NULL);
   fm->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN){
-      return;
+  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+  {
+    return;
   }
-  free_fragment_message(fm->session->mac->plugin,fm);
+  free_fragment_message (fm->session->mac->plugin, fm);
 }
 
 /**
@@ -1474,66 +1503,75 @@ fragmentmessage_timeout (void *cls,
  */
 
 static void
-check_fragment_queue(struct Plugin * plugin)
+check_fragment_queue (struct Plugin *plugin)
 {
-  struct Session * session;
-  struct FragmentMessage * fm;
+  struct Session *session;
+  struct FragmentMessage *fm;
   struct GNUNET_PeerIdentity pid;
 
-  struct PendingMessage * pm;
+  struct PendingMessage *pm;
 
   if (plugin->pending_Fragment_Messages < FRAGMENT_QUEUE_SIZE)
+  {
+    session = get_next_queue_session (plugin);
+    if (session != NULL)
     {
-      session = get_next_queue_session(plugin);
-      if (session != NULL)
-        {
-          pm = session->pending_message_head;
-          GNUNET_CONTAINER_DLL_remove(session->pending_message_head, session->pending_message_tail, pm);
-          session->mac->fragment_messages_out_count++;
-          session->fragment_messages_out_count++;
-          plugin->pending_Fragment_Messages++;
-          GNUNET_assert(pm != NULL);
-
-          fm = GNUNET_malloc(sizeof(struct FragmentMessage));
-          fm->session = session;
-          fm->timeout.abs_value = pm->timeout.abs_value;
-          fm->frag = NULL;
-          fm->fragcontext = GNUNET_FRAGMENT_context_create(plugin->env->stats,
-              WLAN_MTU, &plugin->tracker, GNUNET_TIME_UNIT_SECONDS,
-              &(pm->msg->header), &add_message_for_send,
-              fm);
-          fm->timeout_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_absolute_get_remaining(fm->timeout),fragmentmessage_timeout,fm);
-          GNUNET_CONTAINER_DLL_insert_tail(session->mac->sending_messages_head,session->mac->sending_messages_tail,fm);
-
-          if (pm->transmit_cont != NULL)
-            {
-              pid = session->target;
-              pm->transmit_cont(pm->transmit_cont_cls, &pid, GNUNET_OK);
+      pm = session->pending_message_head;
+      GNUNET_CONTAINER_DLL_remove (session->pending_message_head,
+                                   session->pending_message_tail, pm);
+      session->mac->fragment_messages_out_count++;
+      session->fragment_messages_out_count++;
+      plugin->pending_Fragment_Messages++;
+      GNUNET_assert (pm != NULL);
+
+      fm = GNUNET_malloc (sizeof (struct FragmentMessage));
+      fm->session = session;
+      fm->timeout.abs_value = pm->timeout.abs_value;
+      fm->frag = NULL;
+      fm->fragcontext = GNUNET_FRAGMENT_context_create (plugin->env->stats,
+                                                        WLAN_MTU,
+                                                        &plugin->tracker,
+                                                        GNUNET_TIME_UNIT_SECONDS,
+                                                        &(pm->msg->header),
+                                                        &add_message_for_send,
+                                                        fm);
+      fm->timeout_task =
+          GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
+                                        (fm->timeout), fragmentmessage_timeout,
+                                        fm);
+      GNUNET_CONTAINER_DLL_insert_tail (session->mac->sending_messages_head,
+                                        session->mac->sending_messages_tail,
+                                        fm);
+
+      if (pm->transmit_cont != NULL)
+      {
+        pid = session->target;
+        pm->transmit_cont (pm->transmit_cont_cls, &pid, GNUNET_OK);
 #if DEBUG_wlan
-              GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-                  "called pm->transmit_cont for %p\n", session);
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                         "called pm->transmit_cont for %p\n", session);
 #endif
-            }
-          else
-            {
+      }
+      else
+      {
 #if DEBUG_wlan
-              GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-                  "no pm->transmit_cont for %p\n", session);
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                         "no pm->transmit_cont for %p\n", session);
 #endif
-            }
-          GNUNET_free(pm);
+      }
+      GNUNET_free (pm);
 
-          if (session->pending_message_head != NULL)
-            {
-              //requeue session
-              queue_session(plugin, session);
-            }
+      if (session->pending_message_head != NULL)
+      {
+        //requeue session
+        queue_session (plugin, session);
+      }
 
-        }
     }
+  }
 
   //check if timeout changed
-  set_next_send(plugin);
+  set_next_send (plugin);
 }
 
 /**
@@ -1542,34 +1580,35 @@ check_fragment_queue(struct Plugin * plugin)
  * @param ack pointer to the ack to send
  */
 static void
-send_ack(struct Plugin * plugin, struct AckSendQueue * ack)
+send_ack (struct Plugin *plugin, struct AckSendQueue *ack)
 {
 
   ssize_t bytes;
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "Sending ack for message_id %u for mac endpoint %p, size %u\n",
-      ack->message_id, ack->endpoint,
-      ntohs(ack->hdr->size) - sizeof(struct Radiotap_Send));
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Sending ack for message_id %u for mac endpoint %p, size %u\n",
+                   ack->message_id, ack->endpoint,
+                   ntohs (ack->hdr->size) - sizeof (struct Radiotap_Send));
 #endif
 
-  getRadiotapHeader(plugin, ack->endpoint, ack->radioHeader);
-  getWlanHeader(ack->ieeewlanheader, &ack->endpoint->addr, plugin,
-      ntohs(ack->hdr->size));
+  getRadiotapHeader (plugin, ack->endpoint, ack->radioHeader);
+  getWlanHeader (ack->ieeewlanheader, &ack->endpoint->addr, plugin,
+                 ntohs (ack->hdr->size));
 
-  bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, ack->hdr,
-      ntohs(ack->hdr->size));
+  bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle, ack->hdr,
+                                  ntohs (ack->hdr->size));
   if (bytes == GNUNET_SYSERR)
-    {
-      GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
-          _("Error writing to wlan healper. errno == %d, ERROR: %s\n"),
-          errno, strerror(errno));
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
+                     _
+                     ("Error writing to wlan healper. errno == %d, ERROR: %s\n"),
+                     errno, strerror (errno));
 
-    }
-  GNUNET_assert(bytes != GNUNET_SYSERR);
-  GNUNET_assert(bytes == ntohs(ack->hdr->size));
-  set_next_send(plugin);
+  }
+  GNUNET_assert (bytes != GNUNET_SYSERR);
+  GNUNET_assert (bytes == ntohs (ack->hdr->size));
+  set_next_send (plugin);
 }
 
 /**
@@ -1578,39 +1617,40 @@ send_ack(struct Plugin * plugin, struct AckSendQueue * ack)
  * @param tc TaskContext
  */
 static void
-finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+finish_sending (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct Finish_send * finish = cls;
-  struct Plugin * plugin;
+  struct Finish_send *finish = cls;
+  struct Plugin *plugin;
   ssize_t bytes;
 
   plugin = finish->plugin;
   plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK;
 
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
-    {
-      GNUNET_free (finish->msgstart);
-      GNUNET_free (finish);
-      return;
-    }
-  bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle,
-      finish->msgheader, finish->size);
+  {
+    GNUNET_free (finish->msgstart);
+    GNUNET_free (finish);
+    return;
+  }
+  bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle,
+                                  finish->msgheader, finish->size);
   GNUNET_assert (bytes != GNUNET_SYSERR);
 
   if (bytes != finish->size)
-    {
-      finish->msgheader = finish->msgheader + bytes;
-      finish->size = finish->size - bytes;
-      plugin->server_write_task = GNUNET_SCHEDULER_add_write_file(
-          GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle,
-          &finish_sending, finish);
-    }
+  {
+    finish->msgheader = finish->msgheader + bytes;
+    finish->size = finish->size - bytes;
+    plugin->server_write_task =
+        GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                         plugin->server_stdin_handle,
+                                         &finish_sending, finish);
+  }
   else
-    {
-      GNUNET_free(finish->msgstart);
-      GNUNET_free(finish);
-      set_next_send(plugin);
-    }
+  {
+    GNUNET_free (finish->msgstart);
+    GNUNET_free (finish);
+    set_next_send (plugin);
+  }
 }
 
 /**
@@ -1620,96 +1660,99 @@ finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param tc GNUNET_SCHEDULER_TaskContext
  */
 static void
-do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_transmit (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct Plugin * plugin = cls;
+  struct Plugin *plugin = cls;
 
   plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
-  struct Session * session;
-  struct FragmentMessage * fm;
-  struct Finish_send * finish;
-  struct FragmentMessage_queue * fmq;
-  struct AckSendQueue * ack;
+  struct Session *session;
+  struct FragmentMessage *fm;
+  struct Finish_send *finish;
+  struct FragmentMessage_queue *fmq;
+  struct AckSendQueue *ack;
   ssize_t bytes;
 
   if (plugin->ack_send_queue_head != NULL)
-    {
-      ack = plugin->ack_send_queue_head;
-      GNUNET_CONTAINER_DLL_remove(plugin->ack_send_queue_head,
-          plugin->ack_send_queue_tail, ack);
-      send_ack(plugin, ack);
-      GNUNET_free(ack);
-      return;
-    }
+  {
+    ack = plugin->ack_send_queue_head;
+    GNUNET_CONTAINER_DLL_remove (plugin->ack_send_queue_head,
+                                 plugin->ack_send_queue_tail, ack);
+    send_ack (plugin, ack);
+    GNUNET_free (ack);
+    return;
+  }
 
   //test if a "hello-beacon" has to be send
-  if (GNUNET_TIME_absolute_get_remaining(plugin->beacon_time).rel_value == 0)
-    {
-      send_hello_beacon(plugin);
-      return;
-    }
+  if (GNUNET_TIME_absolute_get_remaining (plugin->beacon_time).rel_value == 0)
+  {
+    send_hello_beacon (plugin);
+    return;
+  }
 
   if (plugin->sending_messages_head != NULL)
-    {
-      fmq = plugin->sending_messages_head;
-      fm = fmq->content;
-      GNUNET_CONTAINER_DLL_remove(plugin->sending_messages_head,plugin->sending_messages_tail,fmq);
-      GNUNET_free(fmq);
+  {
+    fmq = plugin->sending_messages_head;
+    fm = fmq->content;
+    GNUNET_CONTAINER_DLL_remove (plugin->sending_messages_head,
+                                 plugin->sending_messages_tail, fmq);
+    GNUNET_free (fmq);
 
-      session = fm->session;
-      GNUNET_assert(session != NULL);
+    session = fm->session;
+    GNUNET_assert (session != NULL);
 
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,PLUGIN_LOG_NAME,
-          "Sending GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT for fragment message %p, size: %u\n",
-          fm, fm->size);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Sending GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT for fragment message %p, size: %u\n",
+                     fm, fm->size);
 #endif
 
-      getRadiotapHeader(plugin, session->mac, fm->radioHeader);
-      getWlanHeader(fm->ieeewlanheader, &(fm->session->mac->addr), plugin,
-          fm->size);
+    getRadiotapHeader (plugin, session->mac, fm->radioHeader);
+    getWlanHeader (fm->ieeewlanheader, &(fm->session->mac->addr), plugin,
+                   fm->size);
 
-      bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, fm->frag,
-          fm->size);
-      if (bytes == GNUNET_SYSERR)
-        {
-          GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
-              _("Error writing to wlan healper. errno == %d, ERROR: %s\n"),
-              errno, strerror(errno));
+    bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle, fm->frag,
+                                    fm->size);
+    if (bytes == GNUNET_SYSERR)
+    {
+      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
+                       _
+                       ("Error writing to wlan healper. errno == %d, ERROR: %s\n"),
+                       errno, strerror (errno));
 
-        }
-      GNUNET_assert(bytes != GNUNET_SYSERR);
+    }
+    GNUNET_assert (bytes != GNUNET_SYSERR);
 
-      if (bytes != fm->size)
-        {
-          finish = GNUNET_malloc(sizeof( struct Finish_send));
-          finish->plugin = plugin;
-          finish->msgheader = fm->frag + bytes;
-          finish->size = fm->size - bytes;
-          finish->msgstart = (struct GNUNET_MessageHeader *) fm->frag;
-
-          GNUNET_assert(plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK);
-
-          plugin->server_write_task = GNUNET_SCHEDULER_add_write_file(
-              GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle,
-              &finish_sending, finish);
-          fm->frag = NULL;
-        }
-      else
-        {
-          GNUNET_free(fm->frag);
-          fm->frag = NULL;
-          set_next_send(plugin);
-        }
-      GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext);
-      return;
+    if (bytes != fm->size)
+    {
+      finish = GNUNET_malloc (sizeof (struct Finish_send));
+      finish->plugin = plugin;
+      finish->msgheader = fm->frag + bytes;
+      finish->size = fm->size - bytes;
+      finish->msgstart = (struct GNUNET_MessageHeader *) fm->frag;
+
+      GNUNET_assert (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK);
+
+      plugin->server_write_task =
+          GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                           plugin->server_stdin_handle,
+                                           &finish_sending, finish);
+      fm->frag = NULL;
+    }
+    else
+    {
+      GNUNET_free (fm->frag);
+      fm->frag = NULL;
+      set_next_send (plugin);
     }
+    GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext);
+    return;
+  }
 
-  GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
-      "do_transmit did nothing, should not happen!\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
+                   "do_transmit did nothing, should not happen!\n");
 }
 
 /**
@@ -1725,21 +1768,21 @@ do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  *         and transport
  */
 static int
-wlan_plugin_address_suggested(void *cls, const void *addr, size_t addrlen)
+wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen)
 {
   //struct Plugin *plugin = cls;
 
   /* check if the address is plausible; if so,
-   add it to our list! */
+   * add it to our list! */
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
   //FIXME mitm is not checked
   //Mac Address has 6 bytes
   if (addrlen == 6)
-    {
-      /* TODO check for bad addresses like multicast, broadcast, etc */
-      return GNUNET_OK;
-    }
+  {
+    /* TODO check for bad addresses like multicast, broadcast, etc */
+    return GNUNET_OK;
+  }
 
   return GNUNET_SYSERR;
 }
@@ -1771,33 +1814,33 @@ wlan_plugin_address_suggested(void *cls, const void *addr, size_t addrlen)
  *         and does NOT mean that the message was not transmitted (DV)
  */
 static ssize_t
-wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target,
-    const char *msgbuf, size_t msgbuf_size, unsigned int priority,
-    struct GNUNET_TIME_Relative timeout, struct Session *session,
-    const void *addr, size_t addrlen, int force_address,
-    GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
+wlan_plugin_send (void *cls, const struct GNUNET_PeerIdentity *target,
+                  const char *msgbuf, size_t msgbuf_size, unsigned int priority,
+                  struct GNUNET_TIME_Relative timeout, struct Session *session,
+                  const void *addr, size_t addrlen, int force_address,
+                  GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
-  struct Plugin * plugin = cls;
-  struct PendingMessage * newmsg;
-  struct WlanHeader * wlanheader;
+  struct Plugin *plugin = cls;
+  struct PendingMessage *newmsg;
+  struct WlanHeader *wlanheader;
 
   //check if msglen > 0
-  GNUNET_assert(msgbuf_size > 0);
+  GNUNET_assert (msgbuf_size > 0);
 
   //get session if needed
   if (session == NULL)
+  {
+    if (wlan_plugin_address_suggested (plugin, addr, addrlen) == GNUNET_OK)
     {
-      if (wlan_plugin_address_suggested(plugin, addr, addrlen) == GNUNET_OK)
-        {
-          session = get_session(plugin, addr, target);
-        }
-      else
-        {
-          GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
-              _("Wlan Address len %d is wrong\n"), addrlen);
-          return -1;
-        }
+      session = get_session (plugin, addr, target);
+    }
+    else
+    {
+      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
+                       _("Wlan Address len %d is wrong\n"), addrlen);
+      return -1;
     }
+  }
 
   //queue message:
 
@@ -1805,50 +1848,53 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target,
   //test if there is no other message in the "queue"
   //FIXME: to many send requests
   if (session->pending_message_head != NULL)
-    {
-      newmsg = session->pending_message_head;
-      GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
-          "wlan_plugin_send: a pending message is already in the queue for this client\n remaining time to send this message is %u, queued fragment messages for this mac connection %u\n",
-          GNUNET_TIME_absolute_get_remaining(newmsg->timeout).rel_value,
-          session->mac->fragment_messages_out_count);
-    }
+  {
+    newmsg = session->pending_message_head;
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME,
+                     "wlan_plugin_send: a pending message is already in the queue for this client\n remaining time to send this message is %u, queued fragment messages for this mac connection %u\n",
+                     GNUNET_TIME_absolute_get_remaining (newmsg->
+                                                         timeout).rel_value,
+                     session->mac->fragment_messages_out_count);
+  }
 
-  newmsg = GNUNET_malloc(sizeof(struct PendingMessage));
-  newmsg->msg = GNUNET_malloc(msgbuf_size + sizeof(struct WlanHeader));
+  newmsg = GNUNET_malloc (sizeof (struct PendingMessage));
+  newmsg->msg = GNUNET_malloc (msgbuf_size + sizeof (struct WlanHeader));
   wlanheader = newmsg->msg;
   //copy msg to buffer, not fragmented / segmented yet, but with message header
-  wlanheader->header.size = htons(msgbuf_size + sizeof(struct WlanHeader));
-  wlanheader->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA);
-  memcpy(&(wlanheader->target), target, sizeof(struct GNUNET_PeerIdentity));
-  memcpy(&(wlanheader->source), plugin->env->my_identity,
-      sizeof(struct GNUNET_PeerIdentity));
+  wlanheader->header.size = htons (msgbuf_size + sizeof (struct WlanHeader));
+  wlanheader->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA);
+  memcpy (&(wlanheader->target), target, sizeof (struct GNUNET_PeerIdentity));
+  memcpy (&(wlanheader->source), plugin->env->my_identity,
+          sizeof (struct GNUNET_PeerIdentity));
   wlanheader->crc = 0;
-  memcpy(&wlanheader[1], msgbuf, msgbuf_size);
-  wlanheader->crc = htonl(
-      getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader)));
+  memcpy (&wlanheader[1], msgbuf, msgbuf_size);
+  wlanheader->crc =
+      htonl (getcrc32
+             ((char *) wlanheader, msgbuf_size + sizeof (struct WlanHeader)));
   //GNUNET_log_from(GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME,  "Wlan message Header crc: %u, %u\n",getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader)), wlanheader->crc);
   //hexdump(newmsg->msg, msgbuf_size + sizeof(struct WlanHeader));
 
   newmsg->transmit_cont = cont;
   newmsg->transmit_cont_cls = cont_cls;
-  newmsg->timeout = GNUNET_TIME_relative_to_absolute(timeout);
+  newmsg->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 
   newmsg->timeout.abs_value = newmsg->timeout.abs_value - 500;
 
-  newmsg->message_size = msgbuf_size + sizeof(struct WlanHeader);
+  newmsg->message_size = msgbuf_size + sizeof (struct WlanHeader);
 
-  GNUNET_CONTAINER_DLL_insert_tail(session->pending_message_head, session->pending_message_tail, newmsg);
+  GNUNET_CONTAINER_DLL_insert_tail (session->pending_message_head,
+                                    session->pending_message_tail, newmsg);
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "New message for %p with size (incl wlan header) %u added\n", session,
-      newmsg->message_size);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "New message for %p with size (incl wlan header) %u added\n",
+                   session, newmsg->message_size);
 #endif
 
   //queue session
-  queue_session(plugin, session);
+  queue_session (plugin, session);
 
-  check_fragment_queue(plugin);
+  check_fragment_queue (plugin);
   //FIXME not the correct size
   return msgbuf_size;
 
@@ -1860,24 +1906,25 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target,
  * @param endpoin pointer to the MacEndpoint to free
  */
 static void
-free_macendpoint(struct Plugin * plugin, struct MacEndpoint * endpoint)
+free_macendpoint (struct Plugin *plugin, struct MacEndpoint *endpoint)
 {
-  struct Sessionqueue * sessions;
-  struct Sessionqueue * sessions_next;
-  GNUNET_assert(endpoint != NULL);
+  struct Sessionqueue *sessions;
+  struct Sessionqueue *sessions_next;
+
+  GNUNET_assert (endpoint != NULL);
 
   sessions = endpoint->sessions_head;
   while (sessions != NULL)
-    {
-      sessions_next = sessions->next;
-      free_session(plugin, sessions, GNUNET_NO);
-      sessions = sessions_next;
-    }
+  {
+    sessions_next = sessions->next;
+    free_session (plugin, sessions, GNUNET_NO);
+    sessions = sessions_next;
+  }
 
-  GNUNET_CONTAINER_DLL_remove(plugin->mac_head,plugin->mac_tail,endpoint);
+  GNUNET_CONTAINER_DLL_remove (plugin->mac_head, plugin->mac_tail, endpoint);
   if (endpoint->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(endpoint->timeout_task);
-  GNUNET_free(endpoint);
+    GNUNET_SCHEDULER_cancel (endpoint->timeout_task);
+  GNUNET_free (endpoint);
 
 }
 
@@ -1888,75 +1935,75 @@ free_macendpoint(struct Plugin * plugin, struct MacEndpoint * endpoint)
  * @param free_macendpoint if GNUNET_YES and mac endpoint would be empty, free mac endpoint
  */
 static void
-free_session(struct Plugin * plugin, struct Sessionqueue * queue,
-    int do_free_macendpoint)
+free_session (struct Plugin *plugin, struct Sessionqueue *queue,
+              int do_free_macendpoint)
 {
-  struct Sessionqueue * pendingsession;
-  struct Sessionqueue * pendingsession_tmp;
-  struct PendingMessage * pm;
-  struct MacEndpoint * endpoint;
-  struct FragmentMessage * fm;
-  struct FragmentMessage * fmnext;
+  struct Sessionqueue *pendingsession;
+  struct Sessionqueue *pendingsession_tmp;
+  struct PendingMessage *pm;
+  struct MacEndpoint *endpoint;
+  struct FragmentMessage *fm;
+  struct FragmentMessage *fmnext;
   int check = 0;
 
-  GNUNET_assert(queue != NULL);
-  GNUNET_assert(queue->content != NULL);
+  GNUNET_assert (queue != NULL);
+  GNUNET_assert (queue->content != NULL);
 
   //session found
   //is this session pending for send
   pendingsession = plugin->pending_Sessions_head;
   while (pendingsession != NULL)
+  {
+    pendingsession_tmp = pendingsession->next;
+    if (pendingsession->content == queue->content)
     {
-      pendingsession_tmp = pendingsession->next;
-      if (pendingsession->content == queue->content)
-        {
-          plugin->pendingsessions--;
-          GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head,
-              plugin->pending_Sessions_tail,
-              pendingsession);
-          GNUNET_free(pendingsession);
-
-          GNUNET_assert (check == 0);
-          check = 1;
-        }
-      pendingsession = pendingsession_tmp;
+      plugin->pendingsessions--;
+      GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head,
+                                   plugin->pending_Sessions_tail,
+                                   pendingsession);
+      GNUNET_free (pendingsession);
+
+      GNUNET_assert (check == 0);
+      check = 1;
     }
+    pendingsession = pendingsession_tmp;
+  }
 
   endpoint = queue->content->mac;
   fm = endpoint->sending_messages_head;
   while (fm != NULL)
+  {
+    fmnext = fm->next;
+    if (fm->session == queue->content)
     {
-      fmnext = fm->next;
-      if (fm->session == queue->content)
-        {
-          free_fragment_message(plugin, fm);
-        }
-      fm = fmnext;
+      free_fragment_message (plugin, fm);
     }
+    fm = fmnext;
+  }
 
   // remove PendingMessage
   pm = queue->content->pending_message_head;
   while (pm != NULL)
-    {
-      GNUNET_CONTAINER_DLL_remove(queue->content->pending_message_head,queue->content->pending_message_tail,pm);
-      GNUNET_free(pm->msg);
-      GNUNET_free(pm);
-      pm = queue->content->pending_message_head;
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (queue->content->pending_message_head,
+                                 queue->content->pending_message_tail, pm);
+    GNUNET_free (pm->msg);
+    GNUNET_free (pm);
+    pm = queue->content->pending_message_head;
+  }
 
-  GNUNET_CONTAINER_DLL_remove(endpoint->sessions_head ,
-      endpoint->sessions_tail,
-      queue);
+  GNUNET_CONTAINER_DLL_remove (endpoint->sessions_head,
+                               endpoint->sessions_tail, queue);
 
   if (endpoint->sessions_head == NULL && do_free_macendpoint == GNUNET_YES)
-    {
-      free_macendpoint(plugin, endpoint);
-    }
+  {
+    free_macendpoint (plugin, endpoint);
+  }
 
   if (queue->content->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(queue->content->timeout_task);
-  GNUNET_free(queue);
-  check_fragment_queue(plugin);
+    GNUNET_SCHEDULER_cancel (queue->content->timeout_task);
+  GNUNET_free (queue);
+  check_fragment_queue (plugin);
 }
 
 /**
@@ -1968,33 +2015,34 @@ free_session(struct Plugin * plugin, struct Sessionqueue * queue,
  * @param target peer from which to disconnect
  */
 static void
-wlan_plugin_disconnect(void *cls, const struct GNUNET_PeerIdentity *target)
+wlan_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
 {
   struct Plugin *plugin = cls;
-  struct Sessionqueue * queue;
-  struct Sessionqueue * queue_next;
-  struct MacEndpoint * endpoint = plugin->mac_head;
-  struct MacEndpoint * endpoint_next;
+  struct Sessionqueue *queue;
+  struct Sessionqueue *queue_next;
+  struct MacEndpoint *endpoint = plugin->mac_head;
+  struct MacEndpoint *endpoint_next;
+
   // just look at all the session for the needed one
   while (endpoint != NULL)
+  {
+    queue = endpoint->sessions_head;
+    endpoint_next = endpoint->next;
+    while (queue != NULL)
     {
-      queue = endpoint->sessions_head;
-      endpoint_next = endpoint->next;
-      while (queue != NULL)
-        {
-          // content is never NULL
-          GNUNET_assert (queue->content != NULL);
-          queue_next = queue->next;
-          if (memcmp(target, &(queue->content->target),
-              sizeof(struct GNUNET_PeerIdentity)) == 0)
-            {
-              free_session(plugin, queue, GNUNET_YES);
-            }
-          // try next
-          queue = queue_next;
-        }
-      endpoint = endpoint_next;
+      // content is never NULL
+      GNUNET_assert (queue->content != NULL);
+      queue_next = queue->next;
+      if (memcmp (target, &(queue->content->target),
+                  sizeof (struct GNUNET_PeerIdentity)) == 0)
+      {
+        free_session (plugin, queue, GNUNET_YES);
+      }
+      // try next
+      queue = queue_next;
     }
+    endpoint = endpoint_next;
+  }
 }
 
 /**
@@ -2012,26 +2060,29 @@ wlan_plugin_disconnect(void *cls, const struct GNUNET_PeerIdentity *target)
  * @param asc_cls closure for asc
  */
 static void
-wlan_plugin_address_pretty_printer(void *cls, const char *type,
-    const void *addr, size_t addrlen, int numeric,
-    struct GNUNET_TIME_Relative timeout,
-    GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
+wlan_plugin_address_pretty_printer (void *cls, const char *type,
+                                    const void *addr, size_t addrlen,
+                                    int numeric,
+                                    struct GNUNET_TIME_Relative timeout,
+                                    GNUNET_TRANSPORT_AddressStringCallback asc,
+                                    void *asc_cls)
 {
   char ret[92];
-  const unsigned char * input;
+  const unsigned char *input;
 
   //GNUNET_assert(cls !=NULL);
   if (addrlen != 6)
-    {
-      /* invalid address (MAC addresses have 6 bytes) */GNUNET_break (0);
-      asc(asc_cls, NULL);
-      return;
-    }
-  input = (const unsigned char*) addr;
-  GNUNET_snprintf(ret, sizeof(ret),
-      "%s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", PROTOCOL_PREFIX,
-      input[0], input[1], input[2], input[3], input[4], input[5]);
-  asc(asc_cls, ret);
+  {
+    /* invalid address (MAC addresses have 6 bytes) */ GNUNET_break (0);
+    asc (asc_cls, NULL);
+    return;
+  }
+  input = (const unsigned char *) addr;
+  GNUNET_snprintf (ret, sizeof (ret),
+                   "%s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
+                   PROTOCOL_PREFIX, input[0], input[1], input[2], input[3],
+                   input[4], input[5]);
+  asc (asc_cls, ret);
 }
 
 /**
@@ -2041,136 +2092,137 @@ wlan_plugin_address_pretty_printer(void *cls, const char *type,
  * @param hdr pointer to the data
  */
 static void
-wlan_data_message_handler(void *cls, const struct GNUNET_MessageHeader *hdr)
+wlan_data_message_handler (void *cls, const struct GNUNET_MessageHeader *hdr)
 {
-  struct MacEndpoint * endpoint = (struct MacEndpoint *) cls;
-  struct Plugin * plugin = endpoint->plugin;
-  struct WlanHeader * wlanheader;
-  struct Session * session;
+  struct MacEndpoint *endpoint = (struct MacEndpoint *) cls;
+  struct Plugin *plugin = endpoint->plugin;
+  struct WlanHeader *wlanheader;
+  struct Session *session;
+
   //const char * tempmsg;
-  const struct GNUNET_MessageHeader * temp_hdr;
+  const struct GNUNET_MessageHeader *temp_hdr;
   struct GNUNET_PeerIdentity tmpsource;
   int crc;
 
-  if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA)
-    {
+  if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA)
+  {
 
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Func wlan_data_message_handler got GNUNET_MESSAGE_TYPE_WLAN_DATA size: %u\n",
-          ntohs(hdr->size));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Func wlan_data_message_handler got GNUNET_MESSAGE_TYPE_WLAN_DATA size: %u\n",
+                     ntohs (hdr->size));
 #endif
 
-      if (ntohs(hdr->size) < sizeof(struct WlanHeader)
-          + sizeof(struct GNUNET_MessageHeader))
-        {
-          //packet not big enought
-          return;
-        }
+    if (ntohs (hdr->size) < sizeof (struct WlanHeader)
+        + sizeof (struct GNUNET_MessageHeader))
+    {
+      //packet not big enought
+      return;
+    }
 
-      wlanheader = (struct WlanHeader *) hdr;
+    wlanheader = (struct WlanHeader *) hdr;
 
-      session = search_session(plugin, endpoint, &wlanheader->source);
+    session = search_session (plugin, endpoint, &wlanheader->source);
 
-      //tempmsg = (char*) &wlanheader[1];
-      temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1];
-      crc = ntohl(wlanheader->crc);
-      wlanheader->crc = 0;
-      if (getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)) != crc)
-        {
-          //wrong crc, dispose message
-          GNUNET_log_from(GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME,
-              "Wlan message header crc was wrong: %u != %u\n",
-              getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)),
-              crc);
-          hexdump((void *) hdr, ntohs(hdr->size));
-          return;
-        }
+    //tempmsg = (char*) &wlanheader[1];
+    temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1];
+    crc = ntohl (wlanheader->crc);
+    wlanheader->crc = 0;
+    if (getcrc32 ((char *) wlanheader, ntohs (wlanheader->header.size)) != crc)
+    {
+      //wrong crc, dispose message
+      GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME,
+                       "Wlan message header crc was wrong: %u != %u\n",
+                       getcrc32 ((char *) wlanheader,
+                                 ntohs (wlanheader->header.size)), crc);
+      hexdump ((void *) hdr, ntohs (hdr->size));
+      return;
+    }
 
-      //if not in session list
-      if (session == NULL)
-        {
+    //if not in session list
+    if (session == NULL)
+    {
 #if DEBUG_wlan
-          GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-              "WLAN client not in session list: packet size = %u, inner size = %u, header size = %u\n",
-              ntohs(wlanheader->header.size), ntohs(temp_hdr->size),
-              sizeof(struct WlanHeader));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                       "WLAN client not in session list: packet size = %u, inner size = %u, header size = %u\n",
+                       ntohs (wlanheader->header.size), ntohs (temp_hdr->size),
+                       sizeof (struct WlanHeader));
 #endif
-          //try if it is a hello message
-          if (ntohs(wlanheader->header.size) >= ntohs(temp_hdr->size)
-              + sizeof(struct WlanHeader))
-            {
-              if (ntohs(temp_hdr->type) == GNUNET_MESSAGE_TYPE_HELLO)
-                {
-                  if (GNUNET_HELLO_get_id(
-                      (const struct GNUNET_HELLO_Message *) temp_hdr,
-                      &tmpsource) == GNUNET_OK)
-                    {
-                      session = create_session(plugin, endpoint, &tmpsource);
-                    }
-                  else
-                    {
-                      GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
-                          "WLAN client not in session list and hello message is not okay\n");
-                      return;
-                    }
-
-                }
-              else
-                {
-                  GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
-                      "WLAN client not in session list and not a hello message\n");
-                  return;
-                }
-            }
+      //try if it is a hello message
+      if (ntohs (wlanheader->header.size) >= ntohs (temp_hdr->size)
+          + sizeof (struct WlanHeader))
+      {
+        if (ntohs (temp_hdr->type) == GNUNET_MESSAGE_TYPE_HELLO)
+        {
+          if (GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
+                                   temp_hdr, &tmpsource) == GNUNET_OK)
+          {
+            session = create_session (plugin, endpoint, &tmpsource);
+          }
           else
-            {
-              GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
-                  "WLAN client not in session list and message size in does not fit\npacket size = %u, inner size = %u, header size = %u\n",
-                  ntohs(wlanheader->header.size), ntohs(temp_hdr->size),
-                  sizeof(struct WlanHeader));
-              return;
-            }
-        }
-
-      //"receive" the message
+          {
+            GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
+                             "WLAN client not in session list and hello message is not okay\n");
+            return;
+          }
 
-      if (memcmp(&wlanheader->source, &session->target,
-          sizeof(struct GNUNET_PeerIdentity)) != 0)
-        {
-          //wrong peer id
-#if DEBUG_wlan
-          GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-              "WLAN peer source id doesn't match packet peer source id: session %p\n",
-              session);
-#endif
-          return;
         }
-
-      if (memcmp(&wlanheader->target, plugin->env->my_identity,
-          sizeof(struct GNUNET_PeerIdentity)) != 0)
+        else
         {
-          //wrong peer id
-#if DEBUG_wlan
-          GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-              "WLAN peer target id doesn't match our peer id: session %p\n",
-              session);
-#endif
+          GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
+                           "WLAN client not in session list and not a hello message\n");
           return;
         }
+      }
+      else
+      {
+        GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
+                         "WLAN client not in session list and message size in does not fit\npacket size = %u, inner size = %u, header size = %u\n",
+                         ntohs (wlanheader->header.size),
+                         ntohs (temp_hdr->size), sizeof (struct WlanHeader));
+        return;
+      }
+    }
 
-      GNUNET_SERVER_mst_receive(plugin->data_tokenizer, session,
-          (const char *) temp_hdr,
-          ntohs(hdr->size) - sizeof(struct WlanHeader), GNUNET_YES, GNUNET_NO);
+    //"receive" the message
 
+    if (memcmp (&wlanheader->source, &session->target,
+                sizeof (struct GNUNET_PeerIdentity)) != 0)
+    {
+      //wrong peer id
+#if DEBUG_wlan
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                       "WLAN peer source id doesn't match packet peer source id: session %p\n",
+                       session);
+#endif
       return;
     }
-  else
+
+    if (memcmp (&wlanheader->target, plugin->env->my_identity,
+                sizeof (struct GNUNET_PeerIdentity)) != 0)
     {
-      GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
-          "wlan_data_message_handler got wrong message type\n");
+      //wrong peer id
+#if DEBUG_wlan
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                       "WLAN peer target id doesn't match our peer id: session %p\n",
+                       session);
+#endif
       return;
     }
+
+    GNUNET_SERVER_mst_receive (plugin->data_tokenizer, session,
+                               (const char *) temp_hdr,
+                               ntohs (hdr->size) - sizeof (struct WlanHeader),
+                               GNUNET_YES, GNUNET_NO);
+
+    return;
+  }
+  else
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
+                     "wlan_data_message_handler got wrong message type\n");
+    return;
+  }
 }
 
 /**
@@ -2181,30 +2233,35 @@ wlan_data_message_handler(void *cls, const struct GNUNET_MessageHeader *hdr)
  */
 //TODO ATS informations
 static void
-process_data(void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
+process_data (void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
 {
 
-  GNUNET_assert(client != NULL);
-  GNUNET_assert(cls != NULL);
-  struct Session * session = (struct Session *) client;
-  struct Plugin * plugin = (struct Plugin *) cls;
+  GNUNET_assert (client != NULL);
+  GNUNET_assert (cls != NULL);
+  struct Session *session = (struct Session *) client;
+  struct Plugin *plugin = (struct Plugin *) cls;
 
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
-  distance[0].type = htonl(GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
-  distance[0].value = htonl(1);
-  distance[1].type = htonl(GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
-  distance[1].value = htonl(0);
+
+  distance[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
+  distance[0].value = htonl (1);
+  distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
+  distance[1].value = htonl (0);
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "Calling plugin->env->receive for session %p; %s; size: %u\n", session,
-      wlan_plugin_address_to_string(NULL, session->mac->addr.mac, 6),
-      htons(hdr->size));
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Calling plugin->env->receive for session %p; %s; size: %u\n",
+                   session, wlan_plugin_address_to_string (NULL,
+                                                           session->mac->
+                                                           addr.mac, 6),
+                   htons (hdr->size));
 #endif
 
-  plugin->env->receive(plugin->env->cls, &(session->target), hdr,
-      (const struct GNUNET_TRANSPORT_ATS_Information *) &distance, 2, session,
-      (const char*) &session->mac->addr, sizeof(session->mac->addr));
+  plugin->env->receive (plugin->env->cls, &(session->target), hdr,
+                        (const struct GNUNET_TRANSPORT_ATS_Information *)
+                        &distance, 2, session,
+                        (const char *) &session->mac->addr,
+                        sizeof (session->mac->addr));
 }
 
 /**
@@ -2215,166 +2272,183 @@ process_data(void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
  * @param hdr hdr of the GNUNET_MessageHeader
  */
 static void
-wlan_data_helper(void *cls, struct Session_light * session_light,
-    const struct GNUNET_MessageHeader * hdr, const struct Radiotap_rx * rxinfo)
+wlan_data_helper (void *cls, struct Session_light *session_light,
+                  const struct GNUNET_MessageHeader *hdr,
+                  const struct Radiotap_rx *rxinfo)
 {
   struct Plugin *plugin = cls;
-  struct FragmentMessage * fm;
-  struct FragmentMessage * fm2;
+  struct FragmentMessage *fm;
+  struct FragmentMessage *fm2;
 
   //ADVERTISEMENT
-  if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT)
-    {
+  if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT)
+  {
 
-      //TODO better DOS protection, error handling
-      //TODO test first than create session
-      GNUNET_assert(session_light != NULL);
+    //TODO better DOS protection, error handling
+    //TODO test first than create session
+    GNUNET_assert (session_light != NULL);
 
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT size: %u; %s\n",
-          ntohs(hdr->size),
-          wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT size: %u; %s\n",
+                     ntohs (hdr->size),
+                     wlan_plugin_address_to_string (NULL,
+                                                    session_light->addr.mac,
+                                                    6));
 #endif
 
-      if (session_light->macendpoint == NULL)
-        {
-          session_light->macendpoint = get_macendpoint(plugin,
-              &session_light->addr, GNUNET_NO);
-        }
-      GNUNET_assert(GNUNET_HELLO_get_id(
-              (const struct GNUNET_HELLO_Message *) &hdr[1],
-              &(session_light->session->target) ) != GNUNET_SYSERR);
-
+    if (session_light->macendpoint == NULL)
+    {
+      session_light->macendpoint = get_macendpoint (plugin,
+                                                    &session_light->addr,
+                                                    GNUNET_NO);
     }
+    GNUNET_assert (GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
+                                        &hdr[1],
+                                        &(session_light->session->target)) !=
+                   GNUNET_SYSERR);
+
+  }
 
   //FRAGMENT
 
-  else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT)
-    {
+  else if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT)
+  {
 
-      GNUNET_assert(session_light != NULL);
-      if (session_light->macendpoint == NULL)
-        {
-          session_light->macendpoint = get_macendpoint(plugin,
-              &session_light->addr, GNUNET_YES);
-        }
+    GNUNET_assert (session_light != NULL);
+    if (session_light->macendpoint == NULL)
+    {
+      session_light->macendpoint = get_macendpoint (plugin,
+                                                    &session_light->addr,
+                                                    GNUNET_YES);
+    }
 
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT with size: %u; mac endpoint %p: %s\n",
-          ntohs(hdr->size), session_light->macendpoint,
-          wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT with size: %u; mac endpoint %p: %s\n",
+                     ntohs (hdr->size), session_light->macendpoint,
+                     wlan_plugin_address_to_string (NULL,
+                                                    session_light->addr.mac,
+                                                    6));
 #endif
 
-      int ret = GNUNET_DEFRAGMENT_process_fragment(
-          session_light->macendpoint->defrag, hdr);
-      if (ret == GNUNET_NO)
-        {
-          session_light->macendpoint->dups++;
-        }
-      else if (ret == GNUNET_OK)
-        {
-          session_light->macendpoint->fragc++;
-        }
-      set_next_send(plugin);
+    int ret =
+        GNUNET_DEFRAGMENT_process_fragment (session_light->macendpoint->defrag,
+                                            hdr);
 
+    if (ret == GNUNET_NO)
+    {
+      session_light->macendpoint->dups++;
+    }
+    else if (ret == GNUNET_OK)
+    {
+      session_light->macendpoint->fragc++;
     }
+    set_next_send (plugin);
+
+  }
 
   //ACK
 
-  else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT_ACK)
+  else if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT_ACK)
+  {
+    GNUNET_assert (session_light != NULL);
+    if (session_light->macendpoint == NULL)
     {
-      GNUNET_assert(session_light != NULL);
-      if (session_light->macendpoint == NULL)
-        {
-          session_light->macendpoint = get_macendpoint(plugin,
-              &session_light->addr, GNUNET_NO);
-        }
+      session_light->macendpoint = get_macendpoint (plugin,
+                                                    &session_light->addr,
+                                                    GNUNET_NO);
+    }
 
-      if (session_light->macendpoint == NULL)
-        {
+    if (session_light->macendpoint == NULL)
+    {
 #if DEBUG_wlan
-          GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-              "Macendpoint does not exist for this GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; %s\n",
-              ntohs(hdr->size),
-              wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                       "Macendpoint does not exist for this GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; %s\n",
+                       ntohs (hdr->size),
+                       wlan_plugin_address_to_string (NULL,
+                                                      session_light->addr.mac,
+                                                      6));
 #endif
-          return;
-        }
+      return;
+    }
 
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; mac endpoint: %p; %s\n",
-          ntohs(hdr->size), session_light->macendpoint,
-          wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; mac endpoint: %p; %s\n",
+                     ntohs (hdr->size), session_light->macendpoint,
+                     wlan_plugin_address_to_string (NULL,
+                                                    session_light->addr.mac,
+                                                    6));
 #endif
-      fm = session_light->macendpoint->sending_messages_head;
-      while (fm != NULL)
-        {
-          fm2 = fm->next;
-          int ret = GNUNET_FRAGMENT_process_ack(fm->fragcontext, hdr);
-          if (ret == GNUNET_OK)
-            {
+    fm = session_light->macendpoint->sending_messages_head;
+    while (fm != NULL)
+    {
+      fm2 = fm->next;
+      int ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr);
+
+      if (ret == GNUNET_OK)
+      {
 #if DEBUG_wlan_retransmission
-              GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-                  "Got last ack, finished fragment message %p\n", fm);
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                         "Got last ack, finished fragment message %p\n", fm);
 #endif
-              session_light->macendpoint->acks++;
-              fm->session->last_activity = GNUNET_TIME_absolute_get();
-              session_light->macendpoint->last_activity = fm->session->last_activity;
-              free_fragment_message(plugin, fm);
-              check_fragment_queue(plugin);
-              return;
-            }
-          if (ret == GNUNET_NO)
-            {
+        session_light->macendpoint->acks++;
+        fm->session->last_activity = GNUNET_TIME_absolute_get ();
+        session_light->macendpoint->last_activity = fm->session->last_activity;
+        free_fragment_message (plugin, fm);
+        check_fragment_queue (plugin);
+        return;
+      }
+      if (ret == GNUNET_NO)
+      {
 #if DEBUG_wlan_retransmission
-              GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,  "Got ack for: %p\n", fm);
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                         "Got ack for: %p\n", fm);
 #endif
-              session_light->macendpoint->acks++;
-              return;
-            }
-          if (ret == GNUNET_SYSERR)
-            {
+        session_light->macendpoint->acks++;
+        return;
+      }
+      if (ret == GNUNET_SYSERR)
+      {
 
-            }
+      }
 
-          fm = fm2;
-        }
+      fm = fm2;
+    }
 
 #if DEBUG_wlan_retransmission
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "WLAN fragment not in fragment list\n");
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "WLAN fragment not in fragment list\n");
 #endif
-      return;
+    return;
 
-    }
+  }
   else
-    {
-      // TODO Wrong data?
-      GNUNET_log_from(GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME,
-          "WLAN packet inside the WLAN helper packet has not the right type: %u size: %u\n",
-          ntohs(hdr->type), ntohs(hdr->size));
-      GNUNET_break(0);
-      return;
-    }
+  {
+    // TODO Wrong data?
+    GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME,
+                     "WLAN packet inside the WLAN helper packet has not the right type: %u size: %u\n",
+                     ntohs (hdr->type), ntohs (hdr->size));
+    GNUNET_break (0);
+    return;
+  }
 
 #if 0
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "Helper finished\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Helper finished\n");
 #endif
 
 }
 
 //TODO DOXIGEN
 const char *
-macprinter(const u_int8_t * mac)
+macprinter (const u_int8_t * mac)
 {
   static char macstr[20];
 
-  GNUNET_snprintf(macstr, sizeof(macstr), "%X:%X:%X:%X:%X:%X", mac[0], mac[1],
-      mac[2], mac[3], mac[4], mac[5]);
+  GNUNET_snprintf (macstr, sizeof (macstr), "%X:%X:%X:%X:%X:%X", mac[0], mac[1],
+                   mac[2], mac[3], mac[4], mac[5]);
   return macstr;
 }
 
@@ -2384,25 +2458,28 @@ macprinter(const u_int8_t * mac)
  * @param tc pointer to the GNUNET_SCHEDULER_TaskContext
  */
 static void
-macendpoint_timeout (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc){
-  struct MacEndpoint * endpoint = cls;
-  GNUNET_assert(endpoint != NULL);
+macendpoint_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct MacEndpoint *endpoint = cls;
+
+  GNUNET_assert (endpoint != NULL);
   endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN){
-      return;
+  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+  {
+    return;
+  }
+  if (GNUNET_TIME_absolute_get_remaining
+      (GNUNET_TIME_absolute_add
+       (endpoint->last_activity, MACENDPOINT_TIMEOUT)).rel_value == 0)
+  {
+    free_macendpoint (endpoint->plugin, endpoint);
   }
-  if (GNUNET_TIME_absolute_get_remaining(
-      GNUNET_TIME_absolute_add(endpoint->last_activity, MACENDPOINT_TIMEOUT)).rel_value
-      == 0)
-    {
-      free_macendpoint(endpoint->plugin,endpoint);
-    }
   else
-    {
-      endpoint->timeout_task = GNUNET_SCHEDULER_add_delayed(MACENDPOINT_TIMEOUT,
-          &macendpoint_timeout, endpoint);
-    }
+  {
+    endpoint->timeout_task = GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT,
+                                                           &macendpoint_timeout,
+                                                           endpoint);
+  }
 }
 
 /**
@@ -2412,25 +2489,31 @@ macendpoint_timeout (void *cls,
  * @return returns a macendpoint
  */
 static struct MacEndpoint *
-create_macendpoint(struct Plugin *plugin, const struct MacAddress *addr)
+create_macendpoint (struct Plugin *plugin, const struct MacAddress *addr)
 {
-  struct MacEndpoint * newend = GNUNET_malloc(sizeof (struct MacEndpoint));
+  struct MacEndpoint *newend = GNUNET_malloc (sizeof (struct MacEndpoint));
+
   newend->addr = *addr;
   newend->plugin = plugin;
   newend->addr = *addr;
   newend->fragment_messages_out_count = 0;
-  newend->defrag = GNUNET_DEFRAGMENT_context_create(plugin->env->stats,
-      WLAN_MTU, MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, newend,
-      &wlan_data_message_handler, &add_ack_for_send);
-  newend->last_activity = GNUNET_TIME_absolute_get();
-  newend->timeout_task = GNUNET_SCHEDULER_add_delayed(MACENDPOINT_TIMEOUT,
-      &macendpoint_timeout, newend);
+  newend->defrag = GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
+                                                     WLAN_MTU,
+                                                     MESSAGES_IN_DEFRAG_QUEUE_PER_MAC,
+                                                     newend,
+                                                     &wlan_data_message_handler,
+                                                     &add_ack_for_send);
+  newend->last_activity = GNUNET_TIME_absolute_get ();
+  newend->timeout_task = GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT,
+                                                       &macendpoint_timeout,
+                                                       newend);
 
   plugin->mac_count++;
-  GNUNET_CONTAINER_DLL_insert_tail(plugin->mac_head, plugin->mac_tail, newend);
+  GNUNET_CONTAINER_DLL_insert_tail (plugin->mac_head, plugin->mac_tail, newend);
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,  "New Mac Endpoint %p: %s\n", newend,
-      wlan_plugin_address_to_string(NULL, newend->addr.mac, 6));
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "New Mac Endpoint %p: %s\n", newend,
+                   wlan_plugin_address_to_string (NULL, newend->addr.mac, 6));
 #endif
   return newend;
 }
@@ -2443,125 +2526,126 @@ create_macendpoint(struct Plugin *plugin, const struct MacAddress *addr)
  * @param hdr header of the GNUNET_MessageHeader
  */
 static void
-wlan_process_helper(void *cls, void *client,
-    const struct GNUNET_MessageHeader *hdr)
+wlan_process_helper (void *cls, void *client,
+                     const struct GNUNET_MessageHeader *hdr)
 {
   struct Plugin *plugin = cls;
-  struct ieee80211_frame * wlanIeeeHeader = NULL;
-  struct Session_light * session_light = NULL;
-  struct Radiotap_rx * rxinfo;
-  const struct GNUNET_MessageHeader * temp_hdr = NULL;
+  struct ieee80211_frame *wlanIeeeHeader = NULL;
+  struct Session_light *session_light = NULL;
+  struct Radiotap_rx *rxinfo;
+  const struct GNUNET_MessageHeader *temp_hdr = NULL;
 
   int datasize = 0;
   int pos;
 
-  switch (ntohs(hdr->type))
-    {
+  switch (ntohs (hdr->type))
+  {
   case GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA:
 #if DEBUG_wlan
-    GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-        "Func wlan_process_helper got  GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA size: %u\n",
-        ntohs(hdr->size));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Func wlan_process_helper got  GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA size: %u\n",
+                     ntohs (hdr->size));
 #endif
 
     //call wlan_process_helper with the message inside, later with wlan: analyze signal
-    if (ntohs(hdr->size) < sizeof(struct ieee80211_frame)
-        + sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_rx))
-      {
+    if (ntohs (hdr->size) < sizeof (struct ieee80211_frame)
+        + sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_rx))
+    {
 #if DEBUG_wlan
-        GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-            "Size of packet is too small; size: %u min size: %u\n",
-            ntohs(hdr->size),
-            sizeof(struct ieee80211_frame)
-                + sizeof(struct GNUNET_MessageHeader));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                       "Size of packet is too small; size: %u min size: %u\n",
+                       ntohs (hdr->size),
+                       sizeof (struct ieee80211_frame)
+                       + sizeof (struct GNUNET_MessageHeader));
 #endif
-        //GNUNET_break (0);
-        /* FIXME: restart SUID process */
-        return;
-      }
+      //GNUNET_break (0);
+      /* FIXME: restart SUID process */
+      return;
+    }
     rxinfo = (struct Radiotap_rx *) &hdr[1];
     wlanIeeeHeader = (struct ieee80211_frame *) &rxinfo[1];
 
     //process only if it is an broadcast or for this computer both with the gnunet bssid
 
     //check for bssid
-    if (memcmp(&(wlanIeeeHeader->i_addr3), &mac_bssid,
-        sizeof(struct MacAddress)) == 0)
+    if (memcmp (&(wlanIeeeHeader->i_addr3), &mac_bssid,
+                sizeof (struct MacAddress)) == 0)
+    {
+      //check for broadcast or mac
+      if (memcmp (&(wlanIeeeHeader->i_addr1), &bc_all_mac,
+                  sizeof (struct MacAddress) == 0) ||
+          memcmp (&(wlanIeeeHeader->i_addr1), &(plugin->mac_address),
+                  sizeof (struct MacAddress)) == 0)
       {
-        //check for broadcast or mac
-        if (memcmp(&(wlanIeeeHeader->i_addr1), &bc_all_mac,
-            sizeof(struct MacAddress) == 0) || memcmp(
-            &(wlanIeeeHeader->i_addr1), &(plugin->mac_address),
-            sizeof(struct MacAddress)) == 0)
-          {
 
-            // process the inner data
+        // process the inner data
 
 
-            datasize = ntohs(hdr->size) - sizeof(struct ieee80211_frame)
-                - sizeof(struct GNUNET_MessageHeader)
-                - sizeof(struct Radiotap_rx);
+        datasize = ntohs (hdr->size) - sizeof (struct ieee80211_frame)
+            - sizeof (struct GNUNET_MessageHeader)
+            - sizeof (struct Radiotap_rx);
 
-            session_light = GNUNET_malloc(sizeof(struct Session_light));
-            memcpy(&session_light->addr, &(wlanIeeeHeader->i_addr2),
-                sizeof(struct MacAddress));
-            //session_light->session = search_session(plugin,session_light->addr);
+        session_light = GNUNET_malloc (sizeof (struct Session_light));
+        memcpy (&session_light->addr, &(wlanIeeeHeader->i_addr2),
+                sizeof (struct MacAddress));
+        //session_light->session = search_session(plugin,session_light->addr);
 
-            pos = 0;
-            while (pos < datasize)
-              {
-                temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1]
-                    + pos;
+        pos = 0;
+        while (pos < datasize)
+        {
+          temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1] + pos;
 
-                wlan_data_helper(plugin, session_light, temp_hdr, rxinfo);
-                pos += ntohs(temp_hdr->size);
+          wlan_data_helper (plugin, session_light, temp_hdr, rxinfo);
+          pos += ntohs (temp_hdr->size);
 
-              }
+        }
 
-            //clean up
-            GNUNET_free(session_light);
-          }
-        else
-          {
+        //clean up
+        GNUNET_free (session_light);
+      }
+      else
+      {
 #if DEBUG_wlan
-            GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-                "Func wlan_process_helper got wrong MAC: %s\n",
-                macprinter(wlanIeeeHeader->i_addr1));
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                         "Func wlan_process_helper got wrong MAC: %s\n",
+                         macprinter (wlanIeeeHeader->i_addr1));
 #endif
-          }
       }
+    }
     else
-      {
+    {
 #if DEBUG_wlan
-        GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-            "Func wlan_process_helper got wrong BSSID: %s\n",
-            macprinter(wlanIeeeHeader->i_addr2));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                       "Func wlan_process_helper got wrong BSSID: %s\n",
+                       macprinter (wlanIeeeHeader->i_addr2));
 #endif
-      }
+    }
     break;
   case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL:
     //TODO more control messages
     //TODO use struct wlan_helper_control
-    if (ntohs(hdr->size) != sizeof(struct Wlan_Helper_Control_Message))
-      {
-        GNUNET_break (0);
-        /* FIXME: restart SUID process */
-        return;
-      }
-    memcpy(&plugin->mac_address, &hdr[1], sizeof(struct MacAddress));
+    if (ntohs (hdr->size) != sizeof (struct Wlan_Helper_Control_Message))
+    {
+      GNUNET_break (0);
+      /* FIXME: restart SUID process */
+      return;
+    }
+    memcpy (&plugin->mac_address, &hdr[1], sizeof (struct MacAddress));
 #if DEBUG_wlan
-    GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-        "Received WLAN_HELPER_CONTROL message with transport of address %s\n",
-        wlan_plugin_address_to_string(cls, &plugin->mac_address,
-            sizeof(struct MacAddress)));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Received WLAN_HELPER_CONTROL message with transport of address %s\n",
+                     wlan_plugin_address_to_string (cls, &plugin->mac_address,
+                                                    sizeof (struct
+                                                            MacAddress)));
 #endif
-    plugin->env->notify_address(plugin->env->cls, GNUNET_YES,
-        &plugin->mac_address, sizeof(struct MacAddress));
+    plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
+                                 &plugin->mac_address,
+                                 sizeof (struct MacAddress));
     break;
   default:
     GNUNET_break (0);
     return;
-    }
+  }
 }
 
 /**
@@ -2573,36 +2657,39 @@ wlan_process_helper(void *cls, void *client,
  * @param tc the scheduling context
  */
 static void
-wlan_plugin_helper_read(void *cls,
-    const struct GNUNET_SCHEDULER_TaskContext *tc)
+wlan_plugin_helper_read (void *cls,
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
+
   plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
-  char mybuf[WLAN_MTU + sizeof(struct GNUNET_MessageHeader)];
+  char mybuf[WLAN_MTU + sizeof (struct GNUNET_MessageHeader)];
   ssize_t bytes;
 
-  bytes = GNUNET_DISK_file_read(plugin->server_stdout_handle, mybuf,
-      sizeof(mybuf));
+  bytes = GNUNET_DISK_file_read (plugin->server_stdout_handle, mybuf,
+                                 sizeof (mybuf));
   if (bytes <= 0)
-    {
+  {
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          _("Finished reading from wlan-helper stdout with code: %d\n"),
-          bytes);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     _
+                     ("Finished reading from wlan-helper stdout with code: %d\n"),
+                     bytes);
 #endif
-      return;
-    }
-  GNUNET_SERVER_mst_receive(plugin->suid_tokenizer, NULL, mybuf, bytes,
-      GNUNET_NO, GNUNET_NO);
-
-  GNUNET_assert(plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK);
-  plugin->server_read_task = GNUNET_SCHEDULER_add_read_file(
-      GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdout_handle,
-      &wlan_plugin_helper_read, plugin);
+    return;
+  }
+  GNUNET_SERVER_mst_receive (plugin->suid_tokenizer, NULL, mybuf, bytes,
+                             GNUNET_NO, GNUNET_NO);
+
+  GNUNET_assert (plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK);
+  plugin->server_read_task =
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      plugin->server_stdout_handle,
+                                      &wlan_plugin_helper_read, plugin);
 }
 
 /**
@@ -2613,85 +2700,93 @@ wlan_plugin_helper_read(void *cls,
  * @return GNUNET_YES if process was started, GNUNET_SYSERR on error
  */
 static int
-wlan_transport_start_wlan_helper(struct Plugin *plugin, int testmode)
+wlan_transport_start_wlan_helper (struct Plugin *plugin, int testmode)
 {
-  const char * filenamehw = "gnunet-transport-wlan-helper";
-  const char * filenameloopback = "gnunet-transport-wlan-helper-dummy";
-  plugin->server_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_NO, GNUNET_YES);
+  const char *filenamehw = "gnunet-transport-wlan-helper";
+  const char *filenameloopback = "gnunet-transport-wlan-helper-dummy";
+
+  plugin->server_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_NO, GNUNET_YES);
   if (plugin->server_stdout == NULL)
     return GNUNET_SYSERR;
 
-  plugin->server_stdin = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO);
+  plugin->server_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO);
   if (plugin->server_stdin == NULL)
     return GNUNET_SYSERR;
 
   /* Start the server process */
 
   if (testmode == 0)
-    {
+  {
 
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Starting gnunet-wlan-helper process cmd: %s %s %i\n", filenamehw,
-          plugin->interface, testmode);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Starting gnunet-wlan-helper process cmd: %s %s %i\n",
+                     filenamehw, plugin->interface, testmode);
 #endif
 
-      plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin,
-          plugin->server_stdout, filenamehw, filenamehw, plugin->interface,
-          NULL);
-    }
+    plugin->server_proc = GNUNET_OS_start_process (plugin->server_stdin,
+                                                   plugin->server_stdout,
+                                                   filenamehw, filenamehw,
+                                                   plugin->interface, NULL);
+  }
   else if (testmode == 1)
-    {
+  {
 
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Starting gnunet-wlan-helper loopback 1 process cmd: %s %s %i\n",
-          filenameloopback, plugin->interface, testmode);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Starting gnunet-wlan-helper loopback 1 process cmd: %s %s %i\n",
+                     filenameloopback, plugin->interface, testmode);
 #endif
 
-      plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin,
-          plugin->server_stdout, filenameloopback, filenameloopback, "1", NULL);
-    }
+    plugin->server_proc = GNUNET_OS_start_process (plugin->server_stdin,
+                                                   plugin->server_stdout,
+                                                   filenameloopback,
+                                                   filenameloopback, "1", NULL);
+  }
   else if (testmode == 2)
-    {
+  {
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Starting gnunet-wlan-helper loopback 2 process cmd: %s %s %i\n",
-          filenameloopback, plugin->interface, testmode);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Starting gnunet-wlan-helper loopback 2 process cmd: %s %s %i\n",
+                     filenameloopback, plugin->interface, testmode);
 #endif
-      plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin,
-          plugin->server_stdout, filenameloopback, filenameloopback, "2", NULL);
-    }
+    plugin->server_proc = GNUNET_OS_start_process (plugin->server_stdin,
+                                                   plugin->server_stdout,
+                                                   filenameloopback,
+                                                   filenameloopback, "2", NULL);
+  }
   if (plugin->server_proc == NULL)
-    {
+  {
 #if DEBUG_wlan
-      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-          "Failed to start gnunet-wlan-helper process\n");
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                     "Failed to start gnunet-wlan-helper process\n");
 #endif
-      return GNUNET_SYSERR;
-    }
+    return GNUNET_SYSERR;
+  }
 
   /* Close the write end of the read pipe */
-  GNUNET_DISK_pipe_close_end(plugin->server_stdout, GNUNET_DISK_PIPE_END_WRITE);
+  GNUNET_DISK_pipe_close_end (plugin->server_stdout,
+                              GNUNET_DISK_PIPE_END_WRITE);
 
   /* Close the read end of the write pipe */
-  GNUNET_DISK_pipe_close_end(plugin->server_stdin, GNUNET_DISK_PIPE_END_READ);
+  GNUNET_DISK_pipe_close_end (plugin->server_stdin, GNUNET_DISK_PIPE_END_READ);
 
-  plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout,
-      GNUNET_DISK_PIPE_END_READ);
-  plugin->server_stdin_handle = GNUNET_DISK_pipe_handle(plugin->server_stdin,
-      GNUNET_DISK_PIPE_END_WRITE);
+  plugin->server_stdout_handle = GNUNET_DISK_pipe_handle (plugin->server_stdout,
+                                                          GNUNET_DISK_PIPE_END_READ);
+  plugin->server_stdin_handle = GNUNET_DISK_pipe_handle (plugin->server_stdin,
+                                                         GNUNET_DISK_PIPE_END_WRITE);
 
-  GNUNET_assert(plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK);
+  GNUNET_assert (plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK);
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "Adding server_read_task for the wlan-helper\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "Adding server_read_task for the wlan-helper\n");
 #endif
 
-  plugin->server_read_task = GNUNET_SCHEDULER_add_read_file(
-      GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdout_handle,
-      &wlan_plugin_helper_read, plugin);
+  plugin->server_read_task =
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      plugin->server_stdout_handle,
+                                      &wlan_plugin_helper_read, plugin);
 
   return GNUNET_YES;
 }
@@ -2703,55 +2798,55 @@ wlan_transport_start_wlan_helper(struct Plugin *plugin, int testmode)
 
 //FIXME cleanup
 void *
-libgnunet_plugin_transport_wlan_done(void *cls)
+libgnunet_plugin_transport_wlan_done (void *cls)
 {
   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
   struct Plugin *plugin = api->cls;
-  struct MacEndpoint * endpoint = plugin->mac_head;
-  struct MacEndpoint * endpoint_next;
+  struct MacEndpoint *endpoint = plugin->mac_head;
+  struct MacEndpoint *endpoint_next;
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
-      "libgnunet_plugin_transport_wlan_done started\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "libgnunet_plugin_transport_wlan_done started\n");
 #endif
 
-  GNUNET_DISK_pipe_close(plugin->server_stdout);
-  GNUNET_DISK_pipe_close(plugin->server_stdin);
-  GNUNET_OS_process_kill(plugin->server_proc, 9);
-  GNUNET_OS_process_close(plugin->server_proc);
+  GNUNET_DISK_pipe_close (plugin->server_stdout);
+  GNUNET_DISK_pipe_close (plugin->server_stdin);
+  GNUNET_OS_process_kill (plugin->server_proc, 9);
+  GNUNET_OS_process_close (plugin->server_proc);
 
-  GNUNET_assert (cls !=NULL);
+  GNUNET_assert (cls != NULL);
   //free sessions
   while (endpoint != NULL)
-    {
-      endpoint_next = endpoint->next;
-      free_macendpoint(plugin, endpoint);
-      endpoint = endpoint_next;
+  {
+    endpoint_next = endpoint->next;
+    free_macendpoint (plugin, endpoint);
+    endpoint = endpoint_next;
 
-    }
+  }
   if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->server_write_delay_task);
-      plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (plugin->server_write_delay_task);
+    plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (plugin->server_write_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->server_write_task);
-      plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (plugin->server_write_task);
+    plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (plugin->server_read_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(plugin->server_read_task);
-      plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (plugin->server_read_task);
+    plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK;
+  }
 
   if (plugin->suid_tokenizer != NULL)
-    GNUNET_SERVER_mst_destroy(plugin->suid_tokenizer);
+    GNUNET_SERVER_mst_destroy (plugin->suid_tokenizer);
 
   if (plugin->data_tokenizer != NULL)
-    GNUNET_SERVER_mst_destroy(plugin->data_tokenizer);
+    GNUNET_SERVER_mst_destroy (plugin->data_tokenizer);
 
-  GNUNET_free_non_null(plugin->interface);
+  GNUNET_free_non_null (plugin->interface);
   GNUNET_free (plugin);
   GNUNET_free (api);
   return NULL;
@@ -2764,7 +2859,7 @@ libgnunet_plugin_transport_wlan_done(void *cls)
  * @return the 'struct GNUNET_TRANSPORT_PluginFunctions*' or NULL on error
  */
 void *
-libgnunet_plugin_transport_wlan_init(void *cls)
+libgnunet_plugin_transport_wlan_init (void *cls)
 {
   //struct GNUNET_SERVICE_Context *service;
   struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
@@ -2772,7 +2867,7 @@ libgnunet_plugin_transport_wlan_init(void *cls)
   struct Plugin *plugin;
   static unsigned long long testmode = 0;
 
-  GNUNET_assert(cls !=NULL);
+  GNUNET_assert (cls != NULL);
 
   plugin = GNUNET_malloc (sizeof (struct Plugin));
   plugin->env = env;
@@ -2781,13 +2876,14 @@ libgnunet_plugin_transport_wlan_init(void *cls)
   plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK;
   plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK;
   plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK;
-  GNUNET_BANDWIDTH_tracker_init(&plugin->tracker,
-      GNUNET_BANDWIDTH_value_init(100 * 1024 * 1024 / 8), 100);
+  GNUNET_BANDWIDTH_tracker_init (&plugin->tracker,
+                                 GNUNET_BANDWIDTH_value_init (100 * 1024 *
+                                                              1024 / 8), 100);
 
-  plugin->suid_tokenizer = GNUNET_SERVER_mst_create(&wlan_process_helper,
-      plugin);
+  plugin->suid_tokenizer = GNUNET_SERVER_mst_create (&wlan_process_helper,
+                                                     plugin);
 
-  plugin->data_tokenizer = GNUNET_SERVER_mst_create(&process_data, plugin);
+  plugin->data_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin);
 
   //plugin->sessions = GNUNET_malloc (sizeof (struct Sessionqueue));
   //plugin->pending_Sessions_head = GNUNET_malloc (sizeof (struct Sessionqueue));
@@ -2801,30 +2897,35 @@ libgnunet_plugin_transport_wlan_init(void *cls)
   api->address_to_string = &wlan_plugin_address_to_string;
   //read config
 
-  if (GNUNET_CONFIGURATION_have_value(env->cfg, "transport-wlan", "TESTMODE"))
-    {
-      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(env->cfg,
-          "transport-wlan", "TESTMODE", &testmode))
-        testmode = 0; //default value
-    }
+  if (GNUNET_CONFIGURATION_have_value (env->cfg, "transport-wlan", "TESTMODE"))
+  {
+    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (env->cfg,
+                                                                "transport-wlan",
+                                                                "TESTMODE",
+                                                                &testmode))
+      testmode = 0;             //default value
+  }
 
-  if (GNUNET_CONFIGURATION_have_value(env->cfg, "transport-wlan", "INTERFACE"))
+  if (GNUNET_CONFIGURATION_have_value (env->cfg, "transport-wlan", "INTERFACE"))
+  {
+    if (GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-wlan",
+                                               "INTERFACE",
+                                               &(plugin->interface)) !=
+        GNUNET_YES)
     {
-      if (GNUNET_CONFIGURATION_get_value_string(env->cfg, "transport-wlan",
-          "INTERFACE", &(plugin->interface)) != GNUNET_YES)
-        {
-          libgnunet_plugin_transport_wlan_done(api);
-          return NULL;
-        }
+      libgnunet_plugin_transport_wlan_done (api);
+      return NULL;
     }
+  }
 
   //start the plugin
-  set_next_beacon_time(plugin);
+  set_next_beacon_time (plugin);
 
-  wlan_transport_start_wlan_helper(plugin, testmode);
+  wlan_transport_start_wlan_helper (plugin, testmode);
 
 #if DEBUG_wlan
-  GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,  "wlan init finished\n");
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME,
+                   "wlan init finished\n");
 #endif
 
   return api;
diff --git a/src/transport/plugin_transport_wlan.h b/src/transport/plugin_transport_wlan.h
index 8528d984a..aa6a8aa52 100644
--- a/src/transport/plugin_transport_wlan.h
+++ b/src/transport/plugin_transport_wlan.h
@@ -72,41 +72,39 @@ struct WlanHeader
 
 /* Wlan IEEE80211 header default */
 //Informations (in German) http://www.umtslink.at/content/WLAN_macheader-196.html
-static const uint8_t u8aIeeeHeader[] =
-  { 0x08, 0x01, // Frame Control 0x08= 00001000 -> | b1,2 = 0 -> Version 0;
-      //      b3,4 = 10 -> Data; b5-8 = 0 -> Normal Data
-      //        0x01 = 00000001 -> | b1 = 1 to DS; b2 = 0 not from DS;
-      0x00, 0x00, // Duration/ID
-      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // mac1 - in this case receiver
-      0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac2 - in this case sender
-      0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac3 - in this case bssid
-      0x10, 0x86, //Sequence Control
-    };
+static const uint8_t u8aIeeeHeader[] = { 0x08, 0x01,    // Frame Control 0x08= 00001000 -> | b1,2 = 0 -> Version 0;
+  //      b3,4 = 10 -> Data; b5-8 = 0 -> Normal Data
+  //        0x01 = 00000001 -> | b1 = 1 to DS; b2 = 0 not from DS;
+  0x00, 0x00,                   // Duration/ID
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   // mac1 - in this case receiver
+  0x13, 0x22, 0x33, 0x44, 0x55, 0x66,   // mac2 - in this case sender
+  0x13, 0x22, 0x33, 0x44, 0x55, 0x66,   // mac3 - in this case bssid
+  0x10, 0x86,                   //Sequence Control
+};
 
 // gnunet bssid
-static const struct MacAddress mac_bssid =
-  {
-    { 0x13, 0x22, 0x33, 0x44, 0x55, 0x66 } };
+static const struct MacAddress mac_bssid = {
+  {0x13, 0x22, 0x33, 0x44, 0x55, 0x66}
+};
 
 // broadcast mac
-static const struct MacAddress bc_all_mac =
-  {
-    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } };
+static const struct MacAddress bc_all_mac = {
+  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
+};
 
 /* this is the template radiotap header we send packets out with */
 
-static const uint8_t u8aRadiotapHeader[] =
-  { 0x00, 0x00, // <-- radiotap version
-      0x19, 0x00, // <- radiotap header length
-      0x6f, 0x08, 0x00, 0x00, // <-- bitmap
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // <-- timestamp
-      0x00, // <-- flags (Offset +0x10)
-      0x6c, // <-- rate (0ffset +0x11)
-      0x71, 0x09, 0xc0, 0x00, // <-- channel
-      0xde, // <-- antsignal
-      0x00, // <-- antnoise
-      0x01, // <-- antenna
-    };
+static const uint8_t u8aRadiotapHeader[] = { 0x00, 0x00,        // <-- radiotap version
+  0x19, 0x00,                   // <- radiotap header length
+  0x6f, 0x08, 0x00, 0x00,       // <-- bitmap
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,       // <-- timestamp
+  0x00,                         // <-- flags (Offset +0x10)
+  0x6c,                         // <-- rate (0ffset +0x11)
+  0x71, 0x09, 0xc0, 0x00,       // <-- channel
+  0xde,                         // <-- antsignal
+  0x00,                         // <-- antnoise
+  0x01,                         // <-- antenna
+};
 
 struct Radiotap_Send
 {
diff --git a/src/transport/test_plugin_transport.c b/src/transport/test_plugin_transport.c
index 0c335d6ba..e66e04ead 100644
--- a/src/transport/test_plugin_transport.c
+++ b/src/transport/test_plugin_transport.c
@@ -90,9 +90,8 @@ static void
 receive (void *cls,
          const struct GNUNET_PeerIdentity
          *peer, const struct GNUNET_MessageHeader *message,
-         uint32_t distance,
-         const char *sender_address,
-         size_t sender_address_len)
+         uint32_t distance,
+         const char *sender_address, size_t sender_address_len)
 {
   /* do nothing */
 }
@@ -116,8 +115,7 @@ static void
 unload_plugins (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (NULL ==
-                 GNUNET_PLUGIN_unload ("libgnunet_plugin_transport_tcp",
-                                       api));
+                 GNUNET_PLUGIN_unload ("libgnunet_plugin_transport_tcp", api));
   if (my_private_key != NULL)
     GNUNET_CRYPTO_rsa_key_free (my_private_key);
 
@@ -128,6 +126,7 @@ static void
 unload_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+
   unload_plugins (NULL, cfg);
 }
 
@@ -160,8 +159,7 @@ test_validation ()
   soaddr.sin_port = htons (2368 /* FIXME: get from config! */ );
   soaddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
   GNUNET_assert (GNUNET_OK ==
-                 api->check_address (api->cls,
-                                     &soaddr, sizeof (soaddr)));
+                 api->check_address (api->cls, &soaddr, sizeof (soaddr)));
   ok = 0;
   GNUNET_SCHEDULER_add_continuation (&unload_task,
                                      (void *) cfg,
@@ -207,24 +205,23 @@ run (void *cls,
        GNUNET_CONFIGURATION_get_value_filename (c,
                                                 "GNUNETD",
                                                 "HOSTKEY", &keyfile)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown (s);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Transport service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown (s);
+    return;
+  }
   max_connect_per_transport = (uint32_t) tneigh;
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service could not access hostkey.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown (s);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown (s);
+    return;
+  }
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
   GNUNET_CRYPTO_hash (&my_public_key,
                       sizeof (my_public_key), &my_identity.hashPubKey);
@@ -239,12 +236,12 @@ run (void *cls,
   api = GNUNET_PLUGIN_load (libname, &env);
   GNUNET_free (libname);
   if (api == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to load transport plugin for tcp\n"));
-      /* FIXME: set some error code for main */
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to load transport plugin for tcp\n"));
+    /* FIXME: set some error code for main */
+    return;
+  }
   test_validation ();
 }
 
@@ -263,6 +260,7 @@ main (int argc, char *const *argv)
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
+
   char *const argv_prog[] = {
     "test_plugin_transport",
     "-c",
diff --git a/src/transport/test_plugin_transport_http.c b/src/transport/test_plugin_transport_http.c
index 5ba8c573a..921f9ec32 100644
--- a/src/transport/test_plugin_transport_http.c
+++ b/src/transport/test_plugin_transport_http.c
@@ -75,12 +75,12 @@ struct Plugin_Address
   /**
    * Next field for linked list
    */
-  struct Plugin_Address * next;
+  struct Plugin_Address *next;
 
   /**
    * buffer containing data to send
    */
-  void * addr;
+  void *addr;
 
   /**
    * amount of data to sent
@@ -162,9 +162,9 @@ struct HTTP_Transfer
  */
 struct IPv4HttpAddress
 {
-  struct IPv4HttpAddress * next;
+  struct IPv4HttpAddress *next;
 
-  struct IPv4HttpAddress * prev;
+  struct IPv4HttpAddress *prev;
 
   /**
    * IPv4 address, in network byte order.
@@ -184,9 +184,9 @@ struct IPv4HttpAddress
  */
 struct IPv6HttpAddress
 {
-  struct IPv6HttpAddress * next;
+  struct IPv6HttpAddress *next;
 
-  struct IPv6HttpAddress * prev;
+  struct IPv6HttpAddress *prev;
 
   /**
    * IPv6 address.
@@ -229,7 +229,7 @@ static long long unsigned int port;
 /**
  * Peer's addr
  */
-static char * test_addr;
+static char *test_addr;
 
 /**
  * Our statistics handle.
@@ -277,12 +277,13 @@ static struct HTTP_Message buffer_out;
 static struct HTTP_Message buffer_in;
 
 
-struct Plugin_Address * addr_head;
+struct Plugin_Address *addr_head;
 
 /**
  * Did the test pass or fail?
  */
 static int fail_notify_address;
+
 /**
  * Did the test pass or fail?
  */
@@ -386,7 +387,7 @@ static CURLM *multi_handle;
  */
 static GNUNET_SCHEDULER_TaskIdentifier http_task_send;
 
-static char * servicehome;
+static char *servicehome;
 
 /**
  * Shutdown testcase
@@ -394,53 +395,51 @@ static char * servicehome;
 static void
 shutdown_clean ()
 {
-  struct Plugin_Address * tmp;
+  struct Plugin_Address *tmp;
 
   /* Evaluate results  */
   fail = 0;
-  if ( (fail_notify_address == GNUNET_YES) || 
-       (fail_pretty_printer == GNUNET_YES) || 
-       (fail_addr_to_str == GNUNET_YES))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                  "Phase 0: Test plugin functions failed\n");
-      fail = 1;
-    }
-  if ( (test_no_ident.test_failed == GNUNET_YES) || 
-       (test_too_short_ident.test_failed == GNUNET_YES) || 
-       (test_too_long_ident.test_failed == GNUNET_YES) || 
-       (test_valid_ident.test_failed == GNUNET_YES) )
+  if ((fail_notify_address == GNUNET_YES) ||
+      (fail_pretty_printer == GNUNET_YES) || (fail_addr_to_str == GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Phase 0: Test plugin functions failed\n");
+    fail = 1;
+  }
+  if ((test_no_ident.test_failed == GNUNET_YES) ||
+      (test_too_short_ident.test_failed == GNUNET_YES) ||
+      (test_too_long_ident.test_failed == GNUNET_YES) ||
+      (test_valid_ident.test_failed == GNUNET_YES))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Phase 1: Test connect with wrong data failed\n");
     fail = 1;
   }
-  if ( (fail_session_selection_any != GNUNET_NO) || 
-       (fail_session_selection_reliable != GNUNET_NO) ||
-       (fail_session_selection_session != GNUNET_NO) || 
-       (fail_session_selection_session_big != GNUNET_NO) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                  "Phase 2: Test session selection failed\n");
-      fail = 1;
-    }
-  if ( (fail_msgs_transmited_to_local_addrs != count_str_addr) ||
-       (fail_multiple_msgs_in_transmission != 2) || 
-       (fail_msg_transmited_max_size == GNUNET_YES) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                  "Phase 3: Test sending with plugin failed\n");
-      fail = 1;
-    }
+  if ((fail_session_selection_any != GNUNET_NO) ||
+      (fail_session_selection_reliable != GNUNET_NO) ||
+      (fail_session_selection_session != GNUNET_NO) ||
+      (fail_session_selection_session_big != GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Phase 2: Test session selection failed\n");
+    fail = 1;
+  }
+  if ((fail_msgs_transmited_to_local_addrs != count_str_addr) ||
+      (fail_multiple_msgs_in_transmission != 2) ||
+      (fail_msg_transmited_max_size == GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Phase 3: Test sending with plugin failed\n");
+    fail = 1;
+  }
   if (fail != 1)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "All tests successful\n");
-    }
-  
-  api->disconnect(api->cls,&my_identity);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All tests successful\n");
+  }
+
+  api->disconnect (api->cls, &my_identity);
 
-  curl_multi_cleanup(multi_handle);
+  curl_multi_cleanup (multi_handle);
 
   if (NULL != curl_handle)
     curl_easy_cleanup (curl_handle);
@@ -451,37 +450,37 @@ shutdown_clean ()
     tmp = addr_head->next;
     GNUNET_free (addr_head->addr);
     GNUNET_free (addr_head);
-    addr_head=tmp;
+    addr_head = tmp;
   }
 
   if (ti_send != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(ti_send);
+    GNUNET_SCHEDULER_cancel (ti_send);
     ti_send = GNUNET_SCHEDULER_NO_TASK;
   }
 
   if (http_task_send != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(http_task_send);
+    GNUNET_SCHEDULER_cancel (http_task_send);
     http_task_send = GNUNET_SCHEDULER_NO_TASK;
   }
 
   if (ti_timeout != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(ti_timeout);
+    GNUNET_SCHEDULER_cancel (ti_timeout);
     ti_timeout = GNUNET_SCHEDULER_NO_TASK;
   }
 
-  GNUNET_free(test_addr);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Unloading http plugin\n");
-  GNUNET_assert (NULL == GNUNET_PLUGIN_unload ("libgnunet_gnunet_transport_plugin_http", api));
+  GNUNET_free (test_addr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unloading http plugin\n");
+  GNUNET_assert (NULL ==
+                 GNUNET_PLUGIN_unload ("libgnunet_gnunet_transport_plugin_http",
+                                       api));
 
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
   GNUNET_DISK_directory_remove ("/tmp/test_gnunet_transport_plugin_http");
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Exiting testcase\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Exiting testcase\n");
 
   if (servicehome != NULL)
   {
@@ -489,7 +488,7 @@ shutdown_clean ()
     GNUNET_free (servicehome);
   }
 
-  exit(fail);
+  exit (fail);
   return;
 }
 
@@ -502,102 +501,98 @@ shutdown_clean ()
  */
 
 static void
-task_send_cont (void *cls,
-                const struct GNUNET_PeerIdentity * target,
-                int result)
+task_send_cont (void *cls, const struct GNUNET_PeerIdentity *target, int result)
 {
-  if ((cls == &fail_msg_transmited_bigger_max_size) && (result == GNUNET_SYSERR))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Message bigger max msg size was not sent!\n");
-      fail_msg_transmited_bigger_max_size = GNUNET_NO;
-      return;
-    }
+  if ((cls == &fail_msg_transmited_bigger_max_size) &&
+      (result == GNUNET_SYSERR))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Message bigger max msg size was not sent!\n");
+    fail_msg_transmited_bigger_max_size = GNUNET_NO;
+    return;
+  }
 
   if ((cls == &fail_msg_transmited_max_size) && (result == GNUNET_OK))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Message with max msg size succesfully sent!\n",
-                  fail_msgs_transmited_to_local_addrs);
-      fail_msg_transmited_max_size = GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Message with max msg size succesfully sent!\n",
+                fail_msgs_transmited_to_local_addrs);
+    fail_msg_transmited_max_size = GNUNET_NO;
+  }
 }
 
 
-static void run_connection_tests( int phase , void * cls);
+static void run_connection_tests (int phase, void *cls);
 
 /**
  * Recieves messages from plugin, in real world transport
  */
 static struct GNUNET_TIME_Relative
 receive (void *cls, const struct GNUNET_PeerIdentity *peer,
-        const struct GNUNET_MessageHeader *message,
-        const struct GNUNET_TRANSPORT_ATS_Information *ats,
-        uint32_t ats_count,
-        struct Session *session,
-        const char *sender_address,
-        uint16_t sender_address_len)
+         const struct GNUNET_MessageHeader *message,
+         const struct GNUNET_TRANSPORT_ATS_Information *ats,
+         uint32_t ats_count,
+         struct Session *session,
+         const char *sender_address, uint16_t sender_address_len)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Testcase recieved new message from peer `%s' with type %u and length %u, session %X\n",
-              GNUNET_i2s(peer),
-              ntohs(message->type),
-              ntohs(message->size),
-              session);
+              GNUNET_i2s (peer),
+              ntohs (message->type), ntohs (message->size), session);
 
-  if ( (ntohs(message->type)>=10) && 
-       (ntohs(message->type)<20) )
-    {
-      fail_msgs_transmited_to_local_addrs++;
-      if (fail_msgs_transmited_to_local_addrs == count_str_addr)
-        run_connection_tests(2, session);
-    }
-  if ((ntohs(message->type)==20))
-    {
-      fail_session_selection_reliable = GNUNET_NO;
-    }  
-  if ((ntohs(message->type)==21))
-    {
-      fail_session_selection_any = GNUNET_NO;
-    }
-  if ((ntohs(message->type)==22))
-    {
-      fail_session_selection_session = GNUNET_NO;
-    }  
-  if ((ntohs(message->type)==23))
-    {
-      fail_session_selection_session_big = GNUNET_NO;
-      run_connection_tests(3, NULL);
-    }  
-  if ((ntohs(message->type)==30) || (ntohs(message->type)==31))
-    {
-      fail_multiple_msgs_in_transmission ++;
-    }  
-  if ((ntohs(message->type)==32) && (ntohs(message->size) == GNUNET_SERVER_MAX_MESSAGE_SIZE-1))
-    {
-      fail_msg_transmited_max_size = GNUNET_NO;
-      shutdown_clean();
-    }  
+  if ((ntohs (message->type) >= 10) && (ntohs (message->type) < 20))
+  {
+    fail_msgs_transmited_to_local_addrs++;
+    if (fail_msgs_transmited_to_local_addrs == count_str_addr)
+      run_connection_tests (2, session);
+  }
+  if ((ntohs (message->type) == 20))
+  {
+    fail_session_selection_reliable = GNUNET_NO;
+  }
+  if ((ntohs (message->type) == 21))
+  {
+    fail_session_selection_any = GNUNET_NO;
+  }
+  if ((ntohs (message->type) == 22))
+  {
+    fail_session_selection_session = GNUNET_NO;
+  }
+  if ((ntohs (message->type) == 23))
+  {
+    fail_session_selection_session_big = GNUNET_NO;
+    run_connection_tests (3, NULL);
+  }
+  if ((ntohs (message->type) == 30) || (ntohs (message->type) == 31))
+  {
+    fail_multiple_msgs_in_transmission++;
+  }
+  if ((ntohs (message->type) == 32) &&
+      (ntohs (message->size) == GNUNET_SERVER_MAX_MESSAGE_SIZE - 1))
+  {
+    fail_msg_transmited_max_size = GNUNET_NO;
+    shutdown_clean ();
+  }
   return GNUNET_TIME_UNIT_ZERO;
 }
 
 
-static size_t 
+static size_t
 send_function (void *stream, size_t size, size_t nmemb, void *ptr)
 {
   unsigned int len;
 
   len = buffer_out.len;
 
-  if (( buffer_out.pos == len) || (len > (size * nmemb)))
+  if ((buffer_out.pos == len) || (len > (size * nmemb)))
     return 0;
-  memcpy(stream, buffer_out.buf, len);
+  memcpy (stream, buffer_out.buf, len);
   buffer_out.pos = len;
   return len;
 
 }
 
-static size_t 
+static size_t
 recv_function (void *ptr, size_t size, size_t nmemb, void *ctx)
 {
 
@@ -613,54 +608,50 @@ recv_function (void *ptr, size_t size, size_t nmemb, void *ctx)
 }
 
 static size_t
-header_function( void *ptr, size_t size, size_t nmemb, void *stream)
+header_function (void *ptr, size_t size, size_t nmemb, void *stream)
 {
-  struct HTTP_Transfer * res = stream;
-  char * tmp;
+  struct HTTP_Transfer *res = stream;
+  char *tmp;
   unsigned int len = size * nmemb;
 
-  tmp = GNUNET_malloc (  len+1 );
-  memcpy(tmp,ptr,len);
-  if (tmp[len-2] == 13)
-    tmp[len-2]= '\0';
+  tmp = GNUNET_malloc (len + 1);
+  memcpy (tmp, ptr, len);
+  if (tmp[len - 2] == 13)
+    tmp[len - 2] = '\0';
 #if DEBUG_CURL
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Header: `%s'\n",
-              tmp);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Header: `%s'\n", tmp);
 #endif
-  if (0==strcmp (tmp,"HTTP/1.1 100 Continue"))
-    {
-      res->http_result_code=100;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 200 OK"))
-    {
-      res->http_result_code=200;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 400 Bad Request"))
-    {
-      res->http_result_code=400;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 404 Not Found"))
-    {
-      res->http_result_code=404;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 413 Request entity too large"))
-    {
-      res->http_result_code=413;
-    }
-  
+  if (0 == strcmp (tmp, "HTTP/1.1 100 Continue"))
+  {
+    res->http_result_code = 100;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 200 OK"))
+  {
+    res->http_result_code = 200;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 400 Bad Request"))
+  {
+    res->http_result_code = 400;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 404 Not Found"))
+  {
+    res->http_result_code = 404;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 413 Request entity too large"))
+  {
+    res->http_result_code = 413;
+  }
+
   GNUNET_free (tmp);
   return size * nmemb;
 }
 
 
-static size_t 
-send_prepare( struct HTTP_Transfer * result);
+static size_t send_prepare (struct HTTP_Transfer *result);
 
 
-static void 
-send_execute (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+send_execute (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct HTTP_Transfer *res;
 
@@ -674,104 +665,106 @@ send_execute (void *cls,
     return;
 
   do
+  {
+    running = 0;
+    mret = curl_multi_perform (multi_handle, &running);
+    if (running == 0)
     {
-      running = 0;
-      mret = curl_multi_perform (multi_handle, &running);
-      if (running == 0)
-        {
-          do
-            {
+      do
+      {
 
-              msg = curl_multi_info_read (multi_handle, &running);
-              if (msg == NULL)
-                break;
-              /* get session for affected curl handle */
-              //cs = find_session_by_curlhandle (msg->easy_handle);
-              //GNUNET_assert ( cs != NULL );
-              switch (msg->msg)
-                {
-
-                case CURLMSG_DONE:
-                  if ( (msg->data.result != CURLE_OK) &&
-                       (msg->data.result != CURLE_GOT_NOTHING) )
-                    {
-
-                    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                               _("curl failed for `%s' at %s:%d: `%s'\n"),
-                               "curl_multi_perform",
-                               __FILE__,
-                               __LINE__,
-                               curl_easy_strerror (msg->data.result));
-                    /* sending msg failed*/
-                    curl_easy_cleanup(curl_handle);
-                    curl_handle=NULL;
-
-                    run_connection_tests(0, NULL);
-                    }
-                  if (res == &test_no_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                      {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer without any peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  _("Connecting to peer without any peer identification: test failed\n"));
-                  }
-                  if (res == &test_too_short_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                    {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer with too short peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  _("Connecting to peer with too short peer identification: test failed\n"));
-                  }
-                  if (res == &test_too_long_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                      {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer with too long peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                      }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  _("Connecting to peer with too long peer identification: test failed\n"));
-                  }
-                  if (res == &test_valid_ident)
-                  {
-                    if  ((res->http_result_code==200))
-                    {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer with valid peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  "Connecting to peer with valid peer identification: test failed\n");
-                  }
-                  curl_easy_cleanup(curl_handle);
-                  curl_handle=NULL;
-                  if ((res == &test_valid_ident) && (res->test_failed == GNUNET_NO))
-                    run_connection_tests(1, NULL);
-                  run_connection_tests(0, NULL);
-                  return;
-                default:
-                  break;
-                }
+        msg = curl_multi_info_read (multi_handle, &running);
+        if (msg == NULL)
+          break;
+        /* get session for affected curl handle */
+        //cs = find_session_by_curlhandle (msg->easy_handle);
+        //GNUNET_assert ( cs != NULL );
+        switch (msg->msg)
+        {
 
+        case CURLMSG_DONE:
+          if ((msg->data.result != CURLE_OK) &&
+              (msg->data.result != CURLE_GOT_NOTHING))
+          {
+
+            GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                        _("curl failed for `%s' at %s:%d: `%s'\n"),
+                        "curl_multi_perform",
+                        __FILE__,
+                        __LINE__, curl_easy_strerror (msg->data.result));
+            /* sending msg failed */
+            curl_easy_cleanup (curl_handle);
+            curl_handle = NULL;
+
+            run_connection_tests (0, NULL);
+          }
+          if (res == &test_no_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer without any peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer without any peer identification: test failed\n"));
+          }
+          if (res == &test_too_short_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer with too short peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer with too short peer identification: test failed\n"));
+          }
+          if (res == &test_too_long_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer with too long peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
             }
-          while ( (running > 0) );
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer with too long peer identification: test failed\n"));
+          }
+          if (res == &test_valid_ident)
+          {
+            if ((res->http_result_code == 200))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer with valid peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          "Connecting to peer with valid peer identification: test failed\n");
+          }
+          curl_easy_cleanup (curl_handle);
+          curl_handle = NULL;
+          if ((res == &test_valid_ident) && (res->test_failed == GNUNET_NO))
+            run_connection_tests (1, NULL);
+          run_connection_tests (0, NULL);
+          return;
+        default:
+          break;
         }
+
+      }
+      while ((running > 0));
     }
+  }
   while (mret == CURLM_CALL_MULTI_PERFORM);
-  send_prepare(cls);
+  send_prepare (cls);
 }
 
 
@@ -781,7 +774,7 @@ send_execute (void *cls,
  * @return bytes sent to peer
  */
 static size_t
-send_prepare( struct HTTP_Transfer * result)
+send_prepare (struct HTTP_Transfer *result)
 {
   fd_set rs;
   fd_set ws;
@@ -798,34 +791,33 @@ send_prepare( struct HTTP_Transfer * result)
   FD_ZERO (&es);
   mret = curl_multi_fdset (multi_handle, &rs, &ws, &es, &max);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_fdset", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return -1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_fdset", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return -1;
+  }
   mret = curl_multi_timeout (multi_handle, &to);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_timeout", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return -1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_timeout", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return -1;
+  }
 
   grs = GNUNET_NETWORK_fdset_create ();
   gws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
   GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
-  http_task_send = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                GNUNET_SCHEDULER_NO_TASK,
-                                                GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 0),
-                                                grs,
-                                                gws,
-                                                &send_execute,
-                                                result);
+  http_task_send =
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_SECONDS, 0), grs, gws,
+                                   &send_execute, result);
   GNUNET_NETWORK_fdset_destroy (gws);
   GNUNET_NETWORK_fdset_destroy (grs);
 
@@ -836,35 +828,35 @@ send_prepare( struct HTTP_Transfer * result)
 /**
  * function to send data to server
  */
-static int 
-send_data(struct HTTP_Transfer * result,
-          char * url)
+static int
+send_data (struct HTTP_Transfer *result, char *url)
 {
 
-  curl_handle = curl_easy_init();
-  if( NULL == curl_handle)
-    {
-      printf("easy_init failed \n");
-      return GNUNET_SYSERR;
-    }
+  curl_handle = curl_easy_init ();
+  if (NULL == curl_handle)
+  {
+    printf ("easy_init failed \n");
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_CURL
-  curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1L);
+  curl_easy_setopt (curl_handle, CURLOPT_VERBOSE, 1L);
 #endif
-  curl_easy_setopt(curl_handle, CURLOPT_URL, url);
-  curl_easy_setopt(curl_handle, CURLOPT_PUT, 1L);
+  curl_easy_setopt (curl_handle, CURLOPT_URL, url);
+  curl_easy_setopt (curl_handle, CURLOPT_PUT, 1L);
   curl_easy_setopt (curl_handle, CURLOPT_HEADERFUNCTION, &header_function);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEHEADER, result);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEFUNCTION, &recv_function);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEDATA, result);
   curl_easy_setopt (curl_handle, CURLOPT_READFUNCTION, &send_function);
   curl_easy_setopt (curl_handle, CURLOPT_READDATA, result);
-  curl_easy_setopt(curl_handle, CURLOPT_INFILESIZE_LARGE, (curl_off_t) buffer_out.len);
-  curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, 30);
-  curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, 20);
+  curl_easy_setopt (curl_handle, CURLOPT_INFILESIZE_LARGE,
+                    (curl_off_t) buffer_out.len);
+  curl_easy_setopt (curl_handle, CURLOPT_TIMEOUT, 30);
+  curl_easy_setopt (curl_handle, CURLOPT_CONNECTTIMEOUT, 20);
 
-  curl_multi_add_handle(multi_handle, curl_handle);
+  curl_multi_add_handle (multi_handle, curl_handle);
 
-  send_prepare(result);
+  send_prepare (result);
 
   return GNUNET_OK;
 }
@@ -873,58 +865,54 @@ send_data(struct HTTP_Transfer * result,
  * Plugin notifies transport (aka testcase) about its addresses
  */
 static void
-notify_address (void *cls,
-                int add_remove,
-                const void *addr,
-                size_t addrlen)
+notify_address (void *cls, int add_remove, const void *addr, size_t addrlen)
 {
   char address[INET6_ADDRSTRLEN];
   unsigned int port;
-  struct Plugin_Address * pl_addr;
-  struct Plugin_Address * cur;
+  struct Plugin_Address *pl_addr;
+  struct Plugin_Address *cur;
 
   if (addrlen == (sizeof (struct IPv4HttpAddress)))
-    {
-      inet_ntop(AF_INET, (struct in_addr *) addr,address,INET_ADDRSTRLEN);
-      port = ntohs(((struct IPv4HttpAddress *) addr)->u_port);
-    }
+  {
+    inet_ntop (AF_INET, (struct in_addr *) addr, address, INET_ADDRSTRLEN);
+    port = ntohs (((struct IPv4HttpAddress *) addr)->u_port);
+  }
   else if (addrlen == (sizeof (struct IPv6HttpAddress)))
-    {
-      inet_ntop(AF_INET6, (struct in6_addr *) addr,address,INET6_ADDRSTRLEN);
-      port = ntohs(((struct IPv6HttpAddress *) addr)->u6_port);
-    }
+  {
+    inet_ntop (AF_INET6, (struct in6_addr *) addr, address, INET6_ADDRSTRLEN);
+    port = ntohs (((struct IPv6HttpAddress *) addr)->u6_port);
+  }
   else
-    {
+  {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _("Unknown address size: ipv6 has %u ipv4 has %u but this has %u\n"),
+                _
+                ("Unknown address size: ipv6 has %u ipv4 has %u but this has %u\n"),
                 sizeof (struct IPv6HttpAddress),
-                sizeof (struct IPv4HttpAddress),
-                addrlen);
-      return;
-    }
+                sizeof (struct IPv4HttpAddress), addrlen);
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               _("Transport plugin notification for address: `%s':%u\n"),
-              address,
-              port);
-  pl_addr = GNUNET_malloc (sizeof (struct Plugin_Address) );
+              address, port);
+  pl_addr = GNUNET_malloc (sizeof (struct Plugin_Address));
   pl_addr->addrlen = addrlen;
-  pl_addr->addr = GNUNET_malloc(addrlen);
-  memcpy(pl_addr->addr,addr,addrlen);
+  pl_addr->addr = GNUNET_malloc (addrlen);
+  memcpy (pl_addr->addr, addr, addrlen);
   pl_addr->next = NULL;
 
-  if ( NULL == addr_head)
-    {
-      addr_head = pl_addr;
-    }
+  if (NULL == addr_head)
+  {
+    addr_head = pl_addr;
+  }
   else
+  {
+    cur = addr_head;
+    while (NULL != cur->next)
     {
-      cur = addr_head;
-      while (NULL != cur->next)
-        {
-          cur = cur->next;
-        }
-      cur->next = pl_addr;
+      cur = cur->next;
     }
+    cur->next = pl_addr;
+  }
   fail_notify_address_count++;
   fail_notify_address = GNUNET_NO;
 }
@@ -936,8 +924,7 @@ plugin_env_session_end (void *cls,
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Pluging tells me: session %X to peer `%s' ended\n",
-              session,
-              GNUNET_i2s(peer));
+              session, GNUNET_i2s (peer));
 }
 
 
@@ -962,8 +949,7 @@ setup_plugin_environment ()
  * Task shutting down testcase if it a timeout occurs
  */
 static void
-task_timeout (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ti_timeout = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
@@ -971,35 +957,34 @@ task_timeout (void *cls,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testcase timeout\n");
   fail = GNUNET_YES;
-  shutdown_clean();
+  shutdown_clean ();
   return;
 }
 
 
-static void 
-pretty_printer_cb (void *cls,
-                   const char *address)
+static void
+pretty_printer_cb (void *cls, const char *address)
 {
-  if (NULL==address)
+  if (NULL == address)
     return;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Plugin returned pretty address: `%s'\n",
-              address);
+              "Plugin returned pretty address: `%s'\n", address);
   fail_pretty_printer_count++;
 }
 
 /**
  * Runs every single test to test the plugin
  */
-static void 
-run_connection_tests( int phase , void * cls)
+static void
+run_connection_tests (int phase, void *cls)
 {
-  struct GNUNET_MessageHeader * msg;
+  struct GNUNET_MessageHeader *msg;
   unsigned int size;
 
-  if (phase==0)
+  if (phase == 0)
   {
-    char * host_str = NULL;
+    char *host_str = NULL;
+
     /* resetting buffers */
     buffer_in.size = HTTP_BUFFER_SIZE;
     buffer_in.pos = 0;
@@ -1010,217 +995,210 @@ run_connection_tests( int phase , void * cls)
     buffer_out.len = 0;
 
     if (test_no_ident.test_executed == GNUNET_NO)
-      {
-        /* Connecting to peer without identification */
-        const char * ident = "";
-        GNUNET_asprintf (&host_str,
-                         "%s://%s/%s",
-                         PROTOCOL_PREFIX,
-                         test_addr,ident);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer without any peer identification.\n"));
-        test_no_ident.test_executed = GNUNET_YES;
-        send_data ( &test_no_ident, host_str);
-        GNUNET_free (host_str);
-        return;
-      }
+    {
+      /* Connecting to peer without identification */
+      const char *ident = "";
+
+      GNUNET_asprintf (&host_str,
+                       "%s://%s/%s", PROTOCOL_PREFIX, test_addr, ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Connecting to peer without any peer identification.\n"));
+      test_no_ident.test_executed = GNUNET_YES;
+      send_data (&test_no_ident, host_str);
+      GNUNET_free (host_str);
+      return;
+    }
     if (test_too_short_ident.test_executed == GNUNET_NO)
-      {
-        const char * ident = "AAAAAAAAAA";
-        /* Connecting to peer with too short identification */
-        GNUNET_asprintf (&host_str,
-                         "%s://%s/%s",
-                         PROTOCOL_PREFIX,
-                         test_addr,
-                         ident);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer with too short peer identification.\n"));
-        test_too_short_ident.test_executed = GNUNET_YES;
-        send_data ( &test_too_short_ident, host_str);
-        GNUNET_free (host_str);
-        return;
-      }
+    {
+      const char *ident = "AAAAAAAAAA";
+
+      /* Connecting to peer with too short identification */
+      GNUNET_asprintf (&host_str,
+                       "%s://%s/%s", PROTOCOL_PREFIX, test_addr, ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _
+                  ("Connecting to peer with too short peer identification.\n"));
+      test_too_short_ident.test_executed = GNUNET_YES;
+      send_data (&test_too_short_ident, host_str);
+      GNUNET_free (host_str);
+      return;
+    }
 
     if (test_too_long_ident.test_executed == GNUNET_NO)
-      {
-        const char * ident = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+    {
+      const char *ident =
+          "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
 
-        /* Connecting to peer with too long identification */
-        GNUNET_asprintf (&host_str, "%s://%s/%s",PROTOCOL_PREFIX, test_addr,ident);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer with too long peer identification.\n"));
-        test_too_long_ident.test_executed = GNUNET_YES;
-        send_data ( &test_too_long_ident, host_str);
-        GNUNET_free (host_str);
-        return;
+      /* Connecting to peer with too long identification */
+      GNUNET_asprintf (&host_str, "%s://%s/%s", PROTOCOL_PREFIX, test_addr,
+                       ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Connecting to peer with too long peer identification.\n"));
+      test_too_long_ident.test_executed = GNUNET_YES;
+      send_data (&test_too_long_ident, host_str);
+      GNUNET_free (host_str);
+      return;
     }
     if (test_valid_ident.test_executed == GNUNET_NO)
-      {
-        struct GNUNET_CRYPTO_HashAsciiEncoded ident;
-        GNUNET_CRYPTO_hash_to_enc(&my_identity.hashPubKey,&ident);
-        GNUNET_asprintf (&host_str,
-                         "%s://%s/%s%s",
-                         PROTOCOL_PREFIX,
-                         test_addr,
-                         (char *) &ident,
-                         ";0");
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer with valid peer identification.\n"));
-        test_valid_ident.test_executed = GNUNET_YES;
-        send_data ( &test_valid_ident, host_str);
-        GNUNET_free (host_str);
-        return;
-      }
-  }
-  if (phase==1)
     {
+      struct GNUNET_CRYPTO_HashAsciiEncoded ident;
+
+      GNUNET_CRYPTO_hash_to_enc (&my_identity.hashPubKey, &ident);
+      GNUNET_asprintf (&host_str,
+                       "%s://%s/%s%s",
+                       PROTOCOL_PREFIX, test_addr, (char *) &ident, ";0");
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "\nPhase 1: transmit data to all suggested addresses\n\n");
-      /* Using one of the addresses the plugin proposed */
-      GNUNET_assert (addr_head->addr != NULL);
-      
-      struct Plugin_Address * tmp_addr;
-      struct GNUNET_MessageHeader msg;
-      char * tmp = GNUNET_malloc(sizeof(struct GNUNET_MessageHeader));
-      char address[INET6_ADDRSTRLEN];
-      unsigned int port;
-      unsigned int type = 10;
-      
-      msg.size=htons(sizeof(struct GNUNET_MessageHeader));
-      tmp_addr = addr_head;
-      /* send a message to all addresses advertised by plugin */
-      
-      int count = 0;
-      while (tmp_addr != NULL)
-        {
-          if (tmp_addr->addrlen == (sizeof (struct IPv4HttpAddress)))
-            {
-              inet_ntop(AF_INET, (struct in_addr *) tmp_addr->addr,address,INET_ADDRSTRLEN);
-              port = ntohs(((struct IPv4HttpAddress *) tmp_addr->addr)->u_port);
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Sending message to addres no. %u: `%s':%u\n",
-                          count,
-                          address,
-                          port);
-            }
-          if (tmp_addr->addrlen == (sizeof (struct IPv6HttpAddress)))
-            {
-              inet_ntop(AF_INET6, (struct in6_addr *) tmp_addr->addr,address,INET6_ADDRSTRLEN);
-              port = ntohs(((struct IPv6HttpAddress *) tmp_addr->addr)->u6_port);
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Sending message to addres no. %u: `%s':%u\n",
-                          count,
-                          address,
-                          port);
-            }
-          msg.type=htons(type);
-          memcpy(tmp,&msg,sizeof(struct GNUNET_MessageHeader));
-          api->send(api->cls,
-                    &my_identity,
-                    tmp, sizeof(struct GNUNET_MessageHeader),
-                    0, TIMEOUT,
-                    NULL,
-                    tmp_addr->addr, tmp_addr->addrlen,
-                    GNUNET_YES,
-                    &task_send_cont, &fail_msgs_transmited_to_local_addrs);
-          tmp_addr = tmp_addr->next;
-          count++;
-          type++;
-        }
-      GNUNET_free(tmp);
+                  _("Connecting to peer with valid peer identification.\n"));
+      test_valid_ident.test_executed = GNUNET_YES;
+      send_data (&test_valid_ident, host_str);
+      GNUNET_free (host_str);
       return;
     }
+  }
+  if (phase == 1)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\nPhase 1: transmit data to all suggested addresses\n\n");
+    /* Using one of the addresses the plugin proposed */
+    GNUNET_assert (addr_head->addr != NULL);
+
+    struct Plugin_Address *tmp_addr;
+    struct GNUNET_MessageHeader msg;
+    char *tmp = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
+    char address[INET6_ADDRSTRLEN];
+    unsigned int port;
+    unsigned int type = 10;
+
+    msg.size = htons (sizeof (struct GNUNET_MessageHeader));
+    tmp_addr = addr_head;
+    /* send a message to all addresses advertised by plugin */
 
-  if (phase==2)
+    int count = 0;
+
+    while (tmp_addr != NULL)
     {
-      struct Session * session = cls;
-      msg = GNUNET_malloc (sizeof(struct GNUNET_MessageHeader));
-      
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Phase 2: session selection\n\n");
-      size = sizeof(struct GNUNET_MessageHeader);
-      msg->size=htons(size);
-      msg->type = htons(20);
-      api->send(api->cls, 
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, NULL, NULL, 0, GNUNET_NO,
-                &task_send_cont, NULL);
-      
-      msg->type = htons(21);
-      api->send(api->cls, 
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, NULL, NULL, 0, GNUNET_SYSERR,
-                &task_send_cont, NULL);
-      
-      /* answer on session*/
-      size = sizeof( struct GNUNET_MessageHeader);
-      msg->size = htons(size);
-      msg->type = htons(22);
-      api->send(api->cls, 
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, session, NULL, 0, GNUNET_SYSERR,
-                &task_send_cont, NULL);
-      GNUNET_free(msg);
-      
-      /* answer on session with big message not fitting in mhd send buffer*/
-      size = GNUNET_SERVER_MAX_MESSAGE_SIZE-1;
-      msg = GNUNET_malloc (size);
-      msg->size=htons(size);
-      msg->type = htons(23);
-      api->send(api->cls,
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, session, NULL, 0, GNUNET_NO,
-                &task_send_cont, NULL);
-      GNUNET_free(msg);
-      return;
+      if (tmp_addr->addrlen == (sizeof (struct IPv4HttpAddress)))
+      {
+        inet_ntop (AF_INET, (struct in_addr *) tmp_addr->addr, address,
+                   INET_ADDRSTRLEN);
+        port = ntohs (((struct IPv4HttpAddress *) tmp_addr->addr)->u_port);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Sending message to addres no. %u: `%s':%u\n",
+                    count, address, port);
+      }
+      if (tmp_addr->addrlen == (sizeof (struct IPv6HttpAddress)))
+      {
+        inet_ntop (AF_INET6, (struct in6_addr *) tmp_addr->addr, address,
+                   INET6_ADDRSTRLEN);
+        port = ntohs (((struct IPv6HttpAddress *) tmp_addr->addr)->u6_port);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Sending message to addres no. %u: `%s':%u\n",
+                    count, address, port);
+      }
+      msg.type = htons (type);
+      memcpy (tmp, &msg, sizeof (struct GNUNET_MessageHeader));
+      api->send (api->cls,
+                 &my_identity,
+                 tmp, sizeof (struct GNUNET_MessageHeader),
+                 0, TIMEOUT,
+                 NULL,
+                 tmp_addr->addr, tmp_addr->addrlen,
+                 GNUNET_YES,
+                 &task_send_cont, &fail_msgs_transmited_to_local_addrs);
+      tmp_addr = tmp_addr->next;
+      count++;
+      type++;
     }
-  
-  if (phase==3)
-    {
-      
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+    GNUNET_free (tmp);
+    return;
+  }
+
+  if (phase == 2)
+  {
+    struct Session *session = cls;
+
+    msg = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Phase 2: session selection\n\n");
+    size = sizeof (struct GNUNET_MessageHeader);
+    msg->size = htons (size);
+    msg->type = htons (20);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, NULL, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
+
+    msg->type = htons (21);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, NULL, NULL, 0, GNUNET_SYSERR, &task_send_cont, NULL);
+
+    /* answer on session */
+    size = sizeof (struct GNUNET_MessageHeader);
+    msg->size = htons (size);
+    msg->type = htons (22);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, session, NULL, 0, GNUNET_SYSERR,
+               &task_send_cont, NULL);
+    GNUNET_free (msg);
+
+    /* answer on session with big message not fitting in mhd send buffer */
+    size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
+    msg = GNUNET_malloc (size);
+    msg->size = htons (size);
+    msg->type = htons (23);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, session, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
+    GNUNET_free (msg);
+    return;
+  }
+
+  if (phase == 3)
+  {
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Phase 3: send multiple or big messages after disconnect\n\n");
     /* disconnect from peer, so new connections are created */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Disconnect from peer: `%s'\n", GNUNET_i2s(&my_identity));
-    api->disconnect(api->cls, &my_identity);
-    
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect from peer: `%s'\n",
+                GNUNET_i2s (&my_identity));
+    api->disconnect (api->cls, &my_identity);
+
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Phase 3: sending messages\n");
-    /* send a multiple GNUNET_messages at a time*/
-    size = 2 * sizeof(struct GNUNET_MessageHeader);
-    msg = GNUNET_malloc( 2* size);
-    msg->size = htons(size);
-    msg->type = htons(30);
-    struct GNUNET_MessageHeader * msg2 = &msg[2];
-    msg2->size = htons(2 * sizeof(struct GNUNET_MessageHeader));
-    msg2->type = htons(31);
-    api->send(api->cls,
-              &my_identity,
-              (const char *) msg, 4 * sizeof(struct GNUNET_MessageHeader),
-              0, TIMEOUT, NULL,
-              addr_head->addr, addr_head->addrlen,
-              GNUNET_NO,
-              &task_send_cont, &fail_multiple_msgs_in_transmission);
-    GNUNET_free(msg);
+    /* send a multiple GNUNET_messages at a time */
+    size = 2 * sizeof (struct GNUNET_MessageHeader);
+    msg = GNUNET_malloc (2 * size);
+    msg->size = htons (size);
+    msg->type = htons (30);
+    struct GNUNET_MessageHeader *msg2 = &msg[2];
+
+    msg2->size = htons (2 * sizeof (struct GNUNET_MessageHeader));
+    msg2->type = htons (31);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, 4 * sizeof (struct GNUNET_MessageHeader),
+               0, TIMEOUT, NULL,
+               addr_head->addr, addr_head->addrlen,
+               GNUNET_NO, &task_send_cont, &fail_multiple_msgs_in_transmission);
+    GNUNET_free (msg);
     /* send a message with size GNUNET_SERVER_MAX_MESSAGE_SIZE-1  */
 
-    size = GNUNET_SERVER_MAX_MESSAGE_SIZE-1;
-    msg = GNUNET_malloc(size);
-    msg->size = htons(size);
-    msg->type = htons(32);
-    api->send(api->cls,
-              &my_identity,
-              (const char *) msg, size,
-              0, TIMEOUT, NULL,
-              addr_head->addr, addr_head->addrlen,
-              GNUNET_NO,
-              &task_send_cont, &fail_msg_transmited_max_size);
-    GNUNET_free(msg);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "No more tests to run\n");
+    size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
+    msg = GNUNET_malloc (size);
+    msg->size = htons (size);
+    msg->type = htons (32);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, NULL,
+               addr_head->addr, addr_head->addrlen,
+               GNUNET_NO, &task_send_cont, &fail_msg_transmited_max_size);
+    GNUNET_free (msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No more tests to run\n");
   }
 }
 
@@ -1236,12 +1214,13 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  char * libname;
+  char *libname;
+
   cfg = c;
   char *keyfile;
   unsigned long long tneigh;
-  struct Plugin_Address * cur;
-  const char * addr_str;
+  struct Plugin_Address *cur;
+  const char *addr_str;
 
 
   unsigned int suggest_res;
@@ -1260,8 +1239,9 @@ run (void *cls,
   addr_head = NULL;
   count_str_addr = 0;
   /* parse configuration */
-  if (GNUNET_CONFIGURATION_have_value (c,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (c, "PATHS", "SERVICEHOME", &servicehome);
+  if (GNUNET_CONFIGURATION_have_value (c, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (c, "PATHS", "SERVICEHOME",
+                                           &servicehome);
 
   if ((GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_number (c,
@@ -1272,20 +1252,21 @@ run (void *cls,
        GNUNET_CONFIGURATION_get_value_filename (c,
                                                 "GNUNETD",
                                                 "HOSTKEY", &keyfile)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Transport service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      fail = 1;
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Transport service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    fail = 1;
+    return;
+  }
 
   if ((GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (cfg,
-                                             "transport-http",
-                                             "PORT",
-                                             &port)) ||
-     (port > 65535) || (port == 0))
+       GNUNET_CONFIGURATION_get_value_number (cfg,
+                                              "transport-http",
+                                              "PORT",
+                                              &port)) ||
+      (port > 65535) || (port == 0))
   {
     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                      "http",
@@ -1298,16 +1279,17 @@ run (void *cls,
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Transport service could not access hostkey.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      fail = 1;
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    fail = 1;
+    return;
+  }
 
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
-  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_identity.hashPubKey);
+  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
+                      &my_identity.hashPubKey);
 
   /* assertions before start */
   GNUNET_assert ((port > 0) && (port <= 65535));
@@ -1315,9 +1297,8 @@ run (void *cls,
   /* load plugins... */
   setup_plugin_environment ();
   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_http");
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-              _("Loading HTTP transport plugin `%s'\n"),
-              libname);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _("Loading HTTP transport plugin `%s'\n"), libname);
   api = GNUNET_PLUGIN_load (libname, &env);
   GNUNET_free (libname);
   if (api == NULL)
@@ -1332,49 +1313,51 @@ run (void *cls,
   ti_timeout = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &task_timeout, NULL);
 
   /* testing plugin functionality */
-  GNUNET_assert (0!=fail_notify_address_count);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+  GNUNET_assert (0 != fail_notify_address_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Transport plugin returned %u addresses to connect to\n",
               fail_notify_address_count);
 
-  /* testing pretty printer with all addresses obtained from the plugin*/
+  /* testing pretty printer with all addresses obtained from the plugin */
   cur = addr_head;
   while (cur != NULL)
   {
     api->address_pretty_printer (api->cls, "http",
-                                 cur->addr,cur->addrlen, GNUNET_NO,TEST_TIMEOUT,
-                                 &pretty_printer_cb, NULL);
+                                 cur->addr, cur->addrlen, GNUNET_NO,
+                                 TEST_TIMEOUT, &pretty_printer_cb, NULL);
     addr_str = api->address_to_string (api->cls, cur->addr, cur->addrlen);
     suggest_res = api->check_address (api->cls, cur->addr, cur->addrlen);
 
     GNUNET_assert (GNUNET_OK == suggest_res);
     GNUNET_assert (NULL != addr_str);
     count_str_addr++;
-    GNUNET_free ( (char *) addr_str);
+    GNUNET_free ((char *) addr_str);
     cur = cur->next;
   }
   GNUNET_assert (fail_pretty_printer_count > 0);
-  GNUNET_assert (fail_pretty_printer_count==fail_notify_address_count);
-  GNUNET_assert (fail_pretty_printer_count==count_str_addr);
-  fail_pretty_printer=GNUNET_NO;
-  fail_addr_to_str=GNUNET_NO;
+  GNUNET_assert (fail_pretty_printer_count == fail_notify_address_count);
+  GNUNET_assert (fail_pretty_printer_count == count_str_addr);
+  fail_pretty_printer = GNUNET_NO;
+  fail_addr_to_str = GNUNET_NO;
 
   struct IPv4HttpAddress failing_addr;
 
-  /* Suggesting addresses with wrong size*/
-  failing_addr.ipv4_addr = htonl(INADDR_LOOPBACK);
-  failing_addr.u_port = htons(0);
-  suggest_res = api->check_address (api->cls,&failing_addr,sizeof (struct IPv6HttpAddress));
+  /* Suggesting addresses with wrong size */
+  failing_addr.ipv4_addr = htonl (INADDR_LOOPBACK);
+  failing_addr.u_port = htons (0);
+  suggest_res =
+      api->check_address (api->cls, &failing_addr,
+                          sizeof (struct IPv6HttpAddress));
   GNUNET_assert (GNUNET_SYSERR == suggest_res);
 
-  /* Suggesting addresses with wrong address*/
-  failing_addr.ipv4_addr = htonl(0xffc00000);
-  failing_addr.u_port = htons(12389);
-  suggest_res = api->check_address (api->cls,&failing_addr,100);
+  /* Suggesting addresses with wrong address */
+  failing_addr.ipv4_addr = htonl (0xffc00000);
+  failing_addr.u_port = htons (12389);
+  suggest_res = api->check_address (api->cls, &failing_addr, 100);
   GNUNET_assert (GNUNET_SYSERR == suggest_res);
 
   /* test sending to client */
-  multi_handle = curl_multi_init();
+  multi_handle = curl_multi_init ();
 
   /* Setting up buffers */
   buffer_in.size = HTTP_BUFFER_SIZE;
@@ -1403,10 +1386,12 @@ run (void *cls,
   test_valid_ident.test_executed = GNUNET_NO;
   test_valid_ident.test_failed = GNUNET_YES;
 
-  test_addr = (char *) api->address_to_string (api->cls,addr_head->addr,addr_head->addrlen);
+  test_addr =
+      (char *) api->address_to_string (api->cls, addr_head->addr,
+                                       addr_head->addrlen);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Phase 0\n\n"));
-  run_connection_tests(0, NULL);
+  run_connection_tests (0, NULL);
   /* testing finished */
 }
 
@@ -1425,6 +1410,7 @@ main (int argc, char *const *argv)
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
+
   char *const argv_prog[] = {
     "test_gnunet_transport_plugin_http",
     "-c",
@@ -1446,11 +1432,15 @@ main (int argc, char *const *argv)
                     NULL);
 
   struct GNUNET_CONFIGURATION_Handle *cfg;
+
   cfg = GNUNET_CONFIGURATION_create ();
 
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, "test_plugin_transport_data_http.conf"));
-  if (GNUNET_CONFIGURATION_have_value (cfg,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME", &servicehome);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (cfg,
+                                            "test_plugin_transport_data_http.conf"));
+  if (GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME",
+                                           &servicehome);
   GNUNET_DISK_directory_remove (servicehome);
   GNUNET_CONFIGURATION_destroy (cfg);
 
@@ -1458,7 +1448,8 @@ main (int argc, char *const *argv)
          GNUNET_PROGRAM_run (5,
                              argv_prog,
                              "test_gnunet_transport_plugin_http",
-                             "testcase", options, &run, NULL)) ? GNUNET_NO : GNUNET_YES;
+                             "testcase", options, &run,
+                             NULL)) ? GNUNET_NO : GNUNET_YES;
 
   if (servicehome != NULL)
   {
diff --git a/src/transport/test_plugin_transport_https.c b/src/transport/test_plugin_transport_https.c
index 0845c8cd4..e6e71c7f5 100644
--- a/src/transport/test_plugin_transport_https.c
+++ b/src/transport/test_plugin_transport_https.c
@@ -75,12 +75,12 @@ struct Plugin_Address
   /**
    * Next field for linked list
    */
-  struct Plugin_Address * next;
+  struct Plugin_Address *next;
 
   /**
    * buffer containing data to send
    */
-  void * addr;
+  void *addr;
 
   /**
    * amount of data to sent
@@ -162,9 +162,9 @@ struct HTTP_Transfer
  */
 struct IPv4HttpAddress
 {
-  struct IPv4HttpAddress * next;
+  struct IPv4HttpAddress *next;
 
-  struct IPv4HttpAddress * prev;
+  struct IPv4HttpAddress *prev;
 
   /**
    * IPv4 address, in network byte order.
@@ -184,9 +184,9 @@ struct IPv4HttpAddress
  */
 struct IPv6HttpAddress
 {
-  struct IPv6HttpAddress * next;
+  struct IPv6HttpAddress *next;
 
-  struct IPv6HttpAddress * prev;
+  struct IPv6HttpAddress *prev;
 
   /**
    * IPv6 address.
@@ -228,7 +228,7 @@ static long long unsigned int port;
 /**
  * Peer's addr
  */
-static char * test_addr;
+static char *test_addr;
 
 /**
  * Our statistics handle.
@@ -276,12 +276,13 @@ static struct HTTP_Message buffer_out;
 static struct HTTP_Message buffer_in;
 
 
-struct Plugin_Address * addr_head;
+struct Plugin_Address *addr_head;
 
 /**
  * Did the test pass or fail?
  */
 static int fail_notify_address;
+
 /**
  * Did the test pass or fail?
  */
@@ -386,10 +387,10 @@ static CURLM *multi_handle;
 static GNUNET_SCHEDULER_TaskIdentifier http_task_send;
 
 
-static char * key_file;
-static char * cert_file;
+static char *key_file;
+static char *cert_file;
 
-static char * servicehome;
+static char *servicehome;
 
 /**
  * Shutdown testcase
@@ -397,28 +398,41 @@ static char * servicehome;
 static void
 shutdown_clean ()
 {
-  struct Plugin_Address * tmp;
+  struct Plugin_Address *tmp;
 
   /* Evaluate results  */
   fail = 0;
-  if ((fail_notify_address == GNUNET_YES) || (fail_pretty_printer == GNUNET_YES) || (fail_addr_to_str == GNUNET_YES))
+  if ((fail_notify_address == GNUNET_YES) || (fail_pretty_printer == GNUNET_YES)
+      || (fail_addr_to_str == GNUNET_YES))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Phase 0: Test plugin functions failed\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Phase 0: Test plugin functions failed\n"));
     fail = 1;
   }
-  if ((test_no_ident.test_failed == GNUNET_YES) || (test_too_short_ident.test_failed == GNUNET_YES) || (test_too_long_ident.test_failed == GNUNET_YES) || (test_valid_ident.test_failed == GNUNET_YES))
+  if ((test_no_ident.test_failed == GNUNET_YES) ||
+      (test_too_short_ident.test_failed == GNUNET_YES) ||
+      (test_too_long_ident.test_failed == GNUNET_YES) ||
+      (test_valid_ident.test_failed == GNUNET_YES))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Phase 1: Test connect with wrong data failed\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Phase 1: Test connect with wrong data failed\n"));
     fail = 1;
   }
-  if ((fail_session_selection_any != GNUNET_NO) || (fail_session_selection_reliable != GNUNET_NO) || (fail_session_selection_session != GNUNET_NO) || (fail_session_selection_session_big != GNUNET_NO))
+  if ((fail_session_selection_any != GNUNET_NO) ||
+      (fail_session_selection_reliable != GNUNET_NO) ||
+      (fail_session_selection_session != GNUNET_NO) ||
+      (fail_session_selection_session_big != GNUNET_NO))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Phase 2: Test session selection failed\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Phase 2: Test session selection failed\n"));
     fail = 1;
   }
-  if ((fail_msgs_transmited_to_local_addrs != count_str_addr) || (fail_multiple_msgs_in_transmission != 2) || (fail_msg_transmited_max_size == GNUNET_YES))
+  if ((fail_msgs_transmited_to_local_addrs != count_str_addr) ||
+      (fail_multiple_msgs_in_transmission != 2) ||
+      (fail_msg_transmited_max_size == GNUNET_YES))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Phase 3: Test sending with plugin failed\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Phase 3: Test sending with plugin failed\n"));
     fail = 1;
   }
   if (fail != 1)
@@ -426,9 +440,9 @@ shutdown_clean ()
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All tests successful\n");
   }
 
-  api->disconnect(api->cls,&my_identity);
+  api->disconnect (api->cls, &my_identity);
 
-  curl_multi_cleanup(multi_handle);
+  curl_multi_cleanup (multi_handle);
 
   if (NULL != curl_handle)
     curl_easy_cleanup (curl_handle);
@@ -439,49 +453,57 @@ shutdown_clean ()
     tmp = addr_head->next;
     GNUNET_free (addr_head->addr);
     GNUNET_free (addr_head);
-    addr_head=tmp;
+    addr_head = tmp;
   }
 
   if (ti_send != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(ti_send);
+    GNUNET_SCHEDULER_cancel (ti_send);
     ti_send = GNUNET_SCHEDULER_NO_TASK;
   }
 
   if (http_task_send != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(http_task_send);
+    GNUNET_SCHEDULER_cancel (http_task_send);
     http_task_send = GNUNET_SCHEDULER_NO_TASK;
   }
 
   if (ti_timeout != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(ti_timeout);
+    GNUNET_SCHEDULER_cancel (ti_timeout);
     ti_timeout = GNUNET_SCHEDULER_NO_TASK;
   }
 
-  GNUNET_free(test_addr);
+  GNUNET_free (test_addr);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unloading https plugin\n");
-  GNUNET_assert (NULL == GNUNET_PLUGIN_unload ("libgnunet_gnunet_transport_plugin.https", api));
+  GNUNET_assert (NULL ==
+                 GNUNET_PLUGIN_unload
+                 ("libgnunet_gnunet_transport_plugin.https", api));
 
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
   GNUNET_DISK_directory_remove ("/tmp/test_gnunet_transport_plugin.http");
 
   struct stat sbuf;
-  if (0 == stat (cert_file, &sbuf ))
+
+  if (0 == stat (cert_file, &sbuf))
   {
-          if (0 == remove(cert_file))
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed existing certificate file `%s'\n",cert_file);
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",cert_file);
+    if (0 == remove (cert_file))
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Successfully removed existing certificate file `%s'\n",
+                  cert_file);
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",
+                  cert_file);
   }
 
-  if (0 == stat (key_file, &sbuf ))
+  if (0 == stat (key_file, &sbuf))
   {
-          if (0 == remove(key_file))
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed private key file `%s'\n",key_file);
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to private key file `%s'\n",key_file);
+    if (0 == remove (key_file))
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Successfully removed private key file `%s'\n", key_file);
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to private key file `%s'\n",
+                  key_file);
   }
 
   GNUNET_free (key_file);
@@ -495,7 +517,7 @@ shutdown_clean ()
     GNUNET_free (servicehome);
   }
 
-  exit(fail);
+  exit (fail);
   return;
 }
 
@@ -507,97 +529,105 @@ shutdown_clean ()
  * @result GNUNET_OK or GNUNET_SYSERR
  */
 
-static void task_send_cont (void *cls,
-                            const struct GNUNET_PeerIdentity * target,
-                            int result)
+static void
+task_send_cont (void *cls, const struct GNUNET_PeerIdentity *target, int result)
 {
-  if ((cls == &fail_msg_transmited_bigger_max_size) && (result == GNUNET_SYSERR))
+  if ((cls == &fail_msg_transmited_bigger_max_size) &&
+      (result == GNUNET_SYSERR))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message bigger max msg size was not sent!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Message bigger max msg size was not sent!\n");
     fail_msg_transmited_bigger_max_size = GNUNET_NO;
     return;
   }
 
   if ((cls == &fail_msg_transmited_max_size) && (result == GNUNET_OK))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message with max msg size succesfully sent!\n",fail_msgs_transmited_to_local_addrs);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Message with max msg size succesfully sent!\n",
+                fail_msgs_transmited_to_local_addrs);
     fail_msg_transmited_max_size = GNUNET_NO;
   }
 }
 
 
-static void run_connection_tests( int phase , void * cls);
+static void run_connection_tests (int phase, void *cls);
 
 /**
  * Recieves messages from plugin, in real world transport
  */
 static struct GNUNET_TIME_Relative
 receive (void *cls, const struct GNUNET_PeerIdentity *peer,
-        const struct GNUNET_MessageHeader *message,
-        const struct GNUNET_TRANSPORT_ATS_Information *ats,
-        uint32_t ats_count,
-        struct Session *session,
-        const char *sender_address,
-        uint16_t sender_address_len)
+         const struct GNUNET_MessageHeader *message,
+         const struct GNUNET_TRANSPORT_ATS_Information *ats,
+         uint32_t ats_count,
+         struct Session *session,
+         const char *sender_address, uint16_t sender_address_len)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testcase recieved new message from peer `%s' with type %u and length %u, session %X\n",  GNUNET_i2s(peer), ntohs(message->type), ntohs(message->size),session);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testcase recieved new message from peer `%s' with type %u and length %u, session %X\n",
+              GNUNET_i2s (peer), ntohs (message->type), ntohs (message->size),
+              session);
 
-  if ((ntohs(message->type)>=10) && (ntohs(message->type)<20))
+  if ((ntohs (message->type) >= 10) && (ntohs (message->type) < 20))
   {
     fail_msgs_transmited_to_local_addrs++;
     if (fail_msgs_transmited_to_local_addrs == count_str_addr)
-      run_connection_tests(2, session);
+      run_connection_tests (2, session);
   }
 
 
-  if ((ntohs(message->type)==20))
+  if ((ntohs (message->type) == 20))
   {
     fail_session_selection_reliable = GNUNET_NO;
   }
 
-  if ((ntohs(message->type)==21))
+  if ((ntohs (message->type) == 21))
   {
     fail_session_selection_any = GNUNET_NO;
   }
-  if ((ntohs(message->type)==22))
+  if ((ntohs (message->type) == 22))
   {
     fail_session_selection_session = GNUNET_NO;
   }
 
-  if ((ntohs(message->type)==23))
+  if ((ntohs (message->type) == 23))
   {
     fail_session_selection_session_big = GNUNET_NO;
-    run_connection_tests(3, NULL);
+    run_connection_tests (3, NULL);
   }
 
-  if ((ntohs(message->type)==30) || (ntohs(message->type)==31))
+  if ((ntohs (message->type) == 30) || (ntohs (message->type) == 31))
   {
-    fail_multiple_msgs_in_transmission ++;
+    fail_multiple_msgs_in_transmission++;
   }
 
-  if ((ntohs(message->type)==32) && (ntohs(message->size) == GNUNET_SERVER_MAX_MESSAGE_SIZE-1))
+  if ((ntohs (message->type) == 32) &&
+      (ntohs (message->size) == GNUNET_SERVER_MAX_MESSAGE_SIZE - 1))
   {
     fail_msg_transmited_max_size = GNUNET_NO;
-    shutdown_clean();
+    shutdown_clean ();
   }
 
   return GNUNET_TIME_UNIT_ZERO;
 }
 
-static size_t send_function (void *stream, size_t size, size_t nmemb, void *ptr)
+static size_t
+send_function (void *stream, size_t size, size_t nmemb, void *ptr)
 {
   unsigned int len;
 
   len = buffer_out.len;
 
-  if (( buffer_out.pos == len) || (len > (size * nmemb)))
+  if ((buffer_out.pos == len) || (len > (size * nmemb)))
     return 0;
-  memcpy(stream, buffer_out.buf, len);
+  memcpy (stream, buffer_out.buf, len);
   buffer_out.pos = len;
   return len;
 }
 
-static size_t recv_function (void *ptr, size_t size, size_t nmemb, void *ctx)
+static size_t
+recv_function (void *ptr, size_t size, size_t nmemb, void *ctx)
 {
 
   if (buffer_in.pos + size * nmemb > buffer_in.size)
@@ -611,50 +641,51 @@ static size_t recv_function (void *ptr, size_t size, size_t nmemb, void *ctx)
   return buffer_in.pos;
 }
 
-static size_t header_function( void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t
+header_function (void *ptr, size_t size, size_t nmemb, void *stream)
 {
-  struct HTTP_Transfer * res = (struct HTTP_Transfer *) stream;
-  char * tmp;
+  struct HTTP_Transfer *res = (struct HTTP_Transfer *) stream;
+  char *tmp;
   unsigned int len = size * nmemb;
 
-  tmp = GNUNET_malloc (  len+1 );
-  memcpy(tmp,ptr,len);
-  if (tmp[len-2] == 13)
-    tmp[len-2]= '\0';
+  tmp = GNUNET_malloc (len + 1);
+  memcpy (tmp, ptr, len);
+  if (tmp[len - 2] == 13)
+    tmp[len - 2] = '\0';
 #if DEBUG_CURL
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Header: `%s'\n",tmp);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Header: `%s'\n", tmp);
 #endif
-  if (0==strcmp (tmp,"HTTP/1.1 100 Continue"))
+  if (0 == strcmp (tmp, "HTTP/1.1 100 Continue"))
   {
-    res->http_result_code=100;
+    res->http_result_code = 100;
   }
-  if (0==strcmp (tmp,"HTTP/1.1 200 OK"))
+  if (0 == strcmp (tmp, "HTTP/1.1 200 OK"))
   {
-    res->http_result_code=200;
+    res->http_result_code = 200;
   }
-  if (0==strcmp (tmp,"HTTP/1.1 400 Bad Request"))
+  if (0 == strcmp (tmp, "HTTP/1.1 400 Bad Request"))
   {
-    res->http_result_code=400;
+    res->http_result_code = 400;
   }
-  if (0==strcmp (tmp,"HTTP/1.1 404 Not Found"))
+  if (0 == strcmp (tmp, "HTTP/1.1 404 Not Found"))
   {
-    res->http_result_code=404;
+    res->http_result_code = 404;
   }
-  if (0==strcmp (tmp,"HTTP/1.1 413 Request entity too large"))
+  if (0 == strcmp (tmp, "HTTP/1.1 413 Request entity too large"))
   {
-    res->http_result_code=413;
+    res->http_result_code = 413;
   }
 
   GNUNET_free (tmp);
   return size * nmemb;
 }
 
-static size_t send_prepare( struct HTTP_Transfer * result);
+static size_t send_prepare (struct HTTP_Transfer *result);
 
 
 
-static void send_execute (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+send_execute (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct HTTP_Transfer *res;
 
@@ -668,96 +699,107 @@ static void send_execute (void *cls,
     return;
 
   do
+  {
+    running = 0;
+    mret = curl_multi_perform (multi_handle, &running);
+    if (running == 0)
     {
-      running = 0;
-      mret = curl_multi_perform (multi_handle, &running);
-      if (running == 0)
+      do
+      {
+
+        msg = curl_multi_info_read (multi_handle, &running);
+        if (msg == NULL)
+          break;
+        /* get session for affected curl handle */
+        //cs = find_session_by_curlhandle (msg->easy_handle);
+        //GNUNET_assert ( cs != NULL );
+        switch (msg->msg)
         {
-          do
-            {
-
-              msg = curl_multi_info_read (multi_handle, &running);
-              if (msg == NULL)
-                break;
-              /* get session for affected curl handle */
-              //cs = find_session_by_curlhandle (msg->easy_handle);
-              //GNUNET_assert ( cs != NULL );
-              switch (msg->msg)
-                {
-
-                case CURLMSG_DONE:
-                  if ( (msg->data.result != CURLE_OK) &&
-                       (msg->data.result != CURLE_GOT_NOTHING) )
-                    {
-
-                    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                               _("curl failed for `%s' at %s:%d: `%s'\n"),
-                               "curl_multi_perform",
-                               __FILE__,
-                               __LINE__,
-                               curl_easy_strerror (msg->data.result));
-                    /* sending msg failed*/
-                    curl_easy_cleanup(curl_handle);
-                    curl_handle=NULL;
-
-                    run_connection_tests(0, NULL);
-                    }
-                  if (res == &test_no_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                    {
-                      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connecting to peer without any peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Connecting to peer without any peer identification: test failed\n"));
-                  }
-                  if (res == &test_too_short_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                    {
-                      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connecting to peer with too short peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Connecting to peer with too short peer identification: test failed\n"));
-                  }
-                  if (res == &test_too_long_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                      {
-                      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connecting to peer with too long peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                      }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Connecting to peer with too long peer identification: test failed\n"));
-                  }
-                  if (res == &test_valid_ident)
-                  {
-                    if  ((res->http_result_code==200))
-                    {
-                      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connecting to peer with valid peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Connecting to peer with valid peer identification: test failed\n"));
-                  }
-                  curl_easy_cleanup(curl_handle);
-                  curl_handle=NULL;
-                  if ((res == &test_valid_ident) && (res->test_failed == GNUNET_NO))
-                    run_connection_tests(1, NULL);
-                  run_connection_tests(0, NULL);
-                  return;
-                default:
-                  break;
-                }
 
+        case CURLMSG_DONE:
+          if ((msg->data.result != CURLE_OK) &&
+              (msg->data.result != CURLE_GOT_NOTHING))
+          {
+
+            GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                        _("curl failed for `%s' at %s:%d: `%s'\n"),
+                        "curl_multi_perform",
+                        __FILE__,
+                        __LINE__, curl_easy_strerror (msg->data.result));
+            /* sending msg failed */
+            curl_easy_cleanup (curl_handle);
+            curl_handle = NULL;
+
+            run_connection_tests (0, NULL);
+          }
+          if (res == &test_no_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                          "Connecting to peer without any peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer without any peer identification: test failed\n"));
+          }
+          if (res == &test_too_short_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                          "Connecting to peer with too short peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer with too short peer identification: test failed\n"));
+          }
+          if (res == &test_too_long_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                          "Connecting to peer with too long peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
             }
-          while ( (running > 0) );
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer with too long peer identification: test failed\n"));
+          }
+          if (res == &test_valid_ident)
+          {
+            if ((res->http_result_code == 200))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                          "Connecting to peer with valid peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer with valid peer identification: test failed\n"));
+          }
+          curl_easy_cleanup (curl_handle);
+          curl_handle = NULL;
+          if ((res == &test_valid_ident) && (res->test_failed == GNUNET_NO))
+            run_connection_tests (1, NULL);
+          run_connection_tests (0, NULL);
+          return;
+        default:
+          break;
         }
+
+      }
+      while ((running > 0));
     }
+  }
   while (mret == CURLM_CALL_MULTI_PERFORM);
-  send_prepare(cls);
+  send_prepare (cls);
 }
 
 /**
@@ -765,7 +807,8 @@ static void send_execute (void *cls,
  * @param ses session to send data to
  * @return bytes sent to peer
  */
-static size_t send_prepare( struct HTTP_Transfer * result)
+static size_t
+send_prepare (struct HTTP_Transfer *result)
 {
   fd_set rs;
   fd_set ws;
@@ -782,34 +825,33 @@ static size_t send_prepare( struct HTTP_Transfer * result)
   FD_ZERO (&es);
   mret = curl_multi_fdset (multi_handle, &rs, &ws, &es, &max);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_fdset", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return -1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_fdset", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return -1;
+  }
   mret = curl_multi_timeout (multi_handle, &to);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_timeout", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return -1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_timeout", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return -1;
+  }
 
   grs = GNUNET_NETWORK_fdset_create ();
   gws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
   GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
-  http_task_send = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+  http_task_send =
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                    GNUNET_SCHEDULER_NO_TASK,
-                                   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 0),
-                                   grs,
-                                   gws,
-                                   &send_execute,
-                                   result);
+                                   GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_SECONDS, 0), grs, gws,
+                                   &send_execute, result);
   GNUNET_NETWORK_fdset_destroy (gws);
   GNUNET_NETWORK_fdset_destroy (grs);
 
@@ -820,36 +862,38 @@ static size_t send_prepare( struct HTTP_Transfer * result)
 /**
  * function to send data to server
  */
-static int send_data( struct HTTP_Transfer * result, char * url)
+static int
+send_data (struct HTTP_Transfer *result, char *url)
 {
 
-  curl_handle = curl_easy_init();
-  if( NULL == curl_handle)
+  curl_handle = curl_easy_init ();
+  if (NULL == curl_handle)
   {
-    printf("easy_init failed \n");
+    printf ("easy_init failed \n");
     return GNUNET_SYSERR;
   }
 #if DEBUG_CURL
-  curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1L);
+  curl_easy_setopt (curl_handle, CURLOPT_VERBOSE, 1L);
 #endif
-  curl_easy_setopt(curl_handle, CURLOPT_URL, url);
-  curl_easy_setopt(curl_handle, CURLOPT_PUT, 1L);
+  curl_easy_setopt (curl_handle, CURLOPT_URL, url);
+  curl_easy_setopt (curl_handle, CURLOPT_PUT, 1L);
   //curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
-  curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, 0);
-  curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 0);
+  curl_easy_setopt (curl_handle, CURLOPT_SSL_VERIFYPEER, 0);
+  curl_easy_setopt (curl_handle, CURLOPT_SSL_VERIFYHOST, 0);
   curl_easy_setopt (curl_handle, CURLOPT_HEADERFUNCTION, &header_function);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEHEADER, result);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEFUNCTION, &recv_function);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEDATA, result);
   curl_easy_setopt (curl_handle, CURLOPT_READFUNCTION, &send_function);
   curl_easy_setopt (curl_handle, CURLOPT_READDATA, result);
-  curl_easy_setopt(curl_handle, CURLOPT_INFILESIZE_LARGE, (curl_off_t) buffer_out.len);
-  curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, 30);
-  curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, 20);
+  curl_easy_setopt (curl_handle, CURLOPT_INFILESIZE_LARGE,
+                    (curl_off_t) buffer_out.len);
+  curl_easy_setopt (curl_handle, CURLOPT_TIMEOUT, 30);
+  curl_easy_setopt (curl_handle, CURLOPT_CONNECTTIMEOUT, 20);
 
-  curl_multi_add_handle(multi_handle, curl_handle);
+  curl_multi_add_handle (multi_handle, curl_handle);
 
-  send_prepare(result);
+  send_prepare (result);
 
   return GNUNET_OK;
 }
@@ -858,68 +902,66 @@ static int send_data( struct HTTP_Transfer * result, char * url)
  * Plugin notifies transport (aka testcase) about its addresses
  */
 void
-notify_address (void *cls,
-    int add_remove,
-    const void *addr,
-    size_t addrlen)
+notify_address (void *cls, int add_remove, const void *addr, size_t addrlen)
 {
   char address[INET6_ADDRSTRLEN];
   unsigned int port;
-  struct Plugin_Address * pl_addr;
-  struct Plugin_Address * cur;
+  struct Plugin_Address *pl_addr;
+  struct Plugin_Address *cur;
 
   if (addrlen == (sizeof (struct IPv4HttpAddress)))
-    {
-      inet_ntop(AF_INET, (struct in_addr *) addr,address,INET_ADDRSTRLEN);
-      port = ntohs(((struct IPv4HttpAddress *) addr)->u_port);
-    }
+  {
+    inet_ntop (AF_INET, (struct in_addr *) addr, address, INET_ADDRSTRLEN);
+    port = ntohs (((struct IPv4HttpAddress *) addr)->u_port);
+  }
   else if (addrlen == (sizeof (struct IPv6HttpAddress)))
-    {
-      inet_ntop(AF_INET6, (struct in6_addr *) addr,address,INET6_ADDRSTRLEN);
-      port = ntohs(((struct IPv6HttpAddress *) addr)->u6_port);
-    }
+  {
+    inet_ntop (AF_INET6, (struct in6_addr *) addr, address, INET6_ADDRSTRLEN);
+    port = ntohs (((struct IPv6HttpAddress *) addr)->u6_port);
+  }
   else
-    {
+  {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _("Unknown address size: ipv6 has %u ipv4 has %u but this has %u\n"),
+                _
+                ("Unknown address size: ipv6 has %u ipv4 has %u but this has %u\n"),
                 sizeof (struct IPv6HttpAddress),
-                sizeof (struct IPv4HttpAddress),
-                addrlen);
-      return;
-    }
+                sizeof (struct IPv4HttpAddress), addrlen);
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Transport plugin notification for address: `%s':%u\n"),
-              address,
-              port);
-  pl_addr = GNUNET_malloc (sizeof (struct Plugin_Address) );
+              _("Transport plugin notification for address: `%s':%u\n"),
+              address, port);
+  pl_addr = GNUNET_malloc (sizeof (struct Plugin_Address));
   pl_addr->addrlen = addrlen;
-  pl_addr->addr = GNUNET_malloc(addrlen);
-  memcpy(pl_addr->addr,addr,addrlen);
+  pl_addr->addr = GNUNET_malloc (addrlen);
+  memcpy (pl_addr->addr, addr, addrlen);
   pl_addr->next = NULL;
 
-  if ( NULL == addr_head)
-    {
-      addr_head = pl_addr;
-    }
+  if (NULL == addr_head)
+  {
+    addr_head = pl_addr;
+  }
   else
+  {
+    cur = addr_head;
+    while (NULL != cur->next)
     {
-      cur = addr_head;
-      while (NULL != cur->next)
-        {
-          cur = cur->next;
-        }
-      cur->next = pl_addr;
+      cur = cur->next;
     }
+    cur->next = pl_addr;
+  }
   fail_notify_address_count++;
   fail_notify_address = GNUNET_NO;
 }
 
 static void
-plugin_env_session_end  (void *cls,
-                         const struct GNUNET_PeerIdentity *peer,
-                         struct Session *session)
+plugin_env_session_end (void *cls,
+                        const struct GNUNET_PeerIdentity *peer,
+                        struct Session *session)
 {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Pluging tells me: session %X to peer `%s' ended\n", session, GNUNET_i2s(peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Pluging tells me: session %X to peer `%s' ended\n", session,
+              GNUNET_i2s (peer));
 }
 
 
@@ -944,8 +986,7 @@ setup_plugin_environment ()
  * Task shutting down testcase if it a timeout occurs
  */
 static void
-task_timeout (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ti_timeout = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
@@ -953,30 +994,33 @@ task_timeout (void *cls,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testcase timeout\n");
   fail = GNUNET_YES;
-  shutdown_clean();
+  shutdown_clean ();
   return;
 }
 
-static void pretty_printer_cb (void *cls,
-                               const char *address)
+static void
+pretty_printer_cb (void *cls, const char *address)
 {
-  if (NULL==address)
+  if (NULL == address)
     return;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Plugin returned pretty address: `%s'\n",address);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Plugin returned pretty address: `%s'\n",
+              address);
   fail_pretty_printer_count++;
 }
 
 /**
  * Runs every single test to test the plugin
  */
-static void run_connection_tests( int phase , void * cls)
+static void
+run_connection_tests (int phase, void *cls)
 {
-  struct GNUNET_MessageHeader * msg;
+  struct GNUNET_MessageHeader *msg;
   unsigned int size;
 
-  if (phase==0)
+  if (phase == 0)
   {
-    char * host_str = NULL;
+    char *host_str = NULL;
+
     /* resetting buffers */
     buffer_in.size = HTTP_BUFFER_SIZE;
     buffer_in.pos = 0;
@@ -989,154 +1033,192 @@ static void run_connection_tests( int phase , void * cls)
     if (test_no_ident.test_executed == GNUNET_NO)
     {
       /* Connecting to peer without identification */
-      char * ident = "";
-      GNUNET_asprintf (&host_str, "%s://%s/%s",PROTOCOL_PREFIX, test_addr,ident);
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Connecting to peer without any peer identification.\n"));
+      char *ident = "";
+
+      GNUNET_asprintf (&host_str, "%s://%s/%s", PROTOCOL_PREFIX, test_addr,
+                       ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _("Connecting to peer without any peer identification.\n"));
       test_no_ident.test_executed = GNUNET_YES;
-      send_data ( &test_no_ident, host_str);
+      send_data (&test_no_ident, host_str);
       GNUNET_free (host_str);
       return;
     }
     if (test_too_short_ident.test_executed == GNUNET_NO)
     {
-      char * ident = "AAAAAAAAAA";
+      char *ident = "AAAAAAAAAA";
+
       /* Connecting to peer with too short identification */
-      GNUNET_asprintf (&host_str, "%s://%s/%s",PROTOCOL_PREFIX, test_addr,ident);
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Connecting to peer with too short peer identification.\n"));
+      GNUNET_asprintf (&host_str, "%s://%s/%s", PROTOCOL_PREFIX, test_addr,
+                       ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _
+                  ("Connecting to peer with too short peer identification.\n"));
       test_too_short_ident.test_executed = GNUNET_YES;
-      send_data ( &test_too_short_ident, host_str);
+      send_data (&test_too_short_ident, host_str);
       GNUNET_free (host_str);
       return;
     }
 
     if (test_too_long_ident.test_executed == GNUNET_NO)
     {
-      char * ident = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+      char *ident =
+          "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
 
       /* Connecting to peer with too long identification */
-      GNUNET_asprintf (&host_str, "%s://%s/%s",PROTOCOL_PREFIX, test_addr,ident);
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Connecting to peer with too long peer identification.\n"));
+      GNUNET_asprintf (&host_str, "%s://%s/%s", PROTOCOL_PREFIX, test_addr,
+                       ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _("Connecting to peer with too long peer identification.\n"));
       test_too_long_ident.test_executed = GNUNET_YES;
-      send_data ( &test_too_long_ident, host_str);
+      send_data (&test_too_long_ident, host_str);
       GNUNET_free (host_str);
       return;
     }
     if (test_valid_ident.test_executed == GNUNET_NO)
     {
       struct GNUNET_CRYPTO_HashAsciiEncoded ident;
-      GNUNET_CRYPTO_hash_to_enc(&my_identity.hashPubKey,&ident);
-      GNUNET_asprintf (&host_str, "%s://%s/%s%s",PROTOCOL_PREFIX, test_addr,(char *) &ident,";0");
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Connecting to peer with valid peer identification.\n"));
+
+      GNUNET_CRYPTO_hash_to_enc (&my_identity.hashPubKey, &ident);
+      GNUNET_asprintf (&host_str, "%s://%s/%s%s", PROTOCOL_PREFIX, test_addr,
+                       (char *) &ident, ";0");
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _("Connecting to peer with valid peer identification.\n"));
       test_valid_ident.test_executed = GNUNET_YES;
-      send_data ( &test_valid_ident, host_str);
+      send_data (&test_valid_ident, host_str);
       GNUNET_free (host_str);
       return;
     }
   }
-  if (phase==1)
+  if (phase == 1)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("\nPhase 1: transmit data to all suggested addresses\n\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("\nPhase 1: transmit data to all suggested addresses\n\n"));
     /* Using one of the addresses the plugin proposed */
     GNUNET_assert (addr_head->addr != NULL);
 
-    struct Plugin_Address * tmp_addr;
+    struct Plugin_Address *tmp_addr;
     struct GNUNET_MessageHeader msg;
-    char * tmp = GNUNET_malloc(sizeof(struct GNUNET_MessageHeader));
+    char *tmp = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
     char address[INET6_ADDRSTRLEN];
     unsigned int port;
     unsigned int type = 10;
 
-    msg.size=htons(sizeof(struct GNUNET_MessageHeader));
+    msg.size = htons (sizeof (struct GNUNET_MessageHeader));
     tmp_addr = addr_head;
     /* send a message to all addresses advertised by plugin */
 
     int count = 0;
+
     while (tmp_addr != NULL)
     {
       if (tmp_addr->addrlen == (sizeof (struct IPv4HttpAddress)))
-        {
-          inet_ntop(AF_INET, (struct in_addr *) tmp_addr->addr,address,INET_ADDRSTRLEN);
-          port = ntohs(((struct IPv4HttpAddress *) tmp_addr->addr)->u_port);
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Sending message to addres no. %u: `%s':%u\n", count,address, port);
-        }
+      {
+        inet_ntop (AF_INET, (struct in_addr *) tmp_addr->addr, address,
+                   INET_ADDRSTRLEN);
+        port = ntohs (((struct IPv4HttpAddress *) tmp_addr->addr)->u_port);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Sending message to addres no. %u: `%s':%u\n", count,
+                    address, port);
+      }
       if (tmp_addr->addrlen == (sizeof (struct IPv6HttpAddress)))
-        {
-          inet_ntop(AF_INET6, (struct in6_addr *) tmp_addr->addr,address,INET6_ADDRSTRLEN);
-          port = ntohs(((struct IPv6HttpAddress *) tmp_addr->addr)->u6_port);
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Sending message to addres no. %u: `%s':%u\n", count,address,port);
-        }
-      msg.type=htons(type);
-      memcpy(tmp,&msg,sizeof(struct GNUNET_MessageHeader));
-      api->send(api->cls, &my_identity, tmp, sizeof(struct GNUNET_MessageHeader), 0, TIMEOUT, NULL,tmp_addr->addr, tmp_addr->addrlen, GNUNET_YES, &task_send_cont, &fail_msgs_transmited_to_local_addrs);
+      {
+        inet_ntop (AF_INET6, (struct in6_addr *) tmp_addr->addr, address,
+                   INET6_ADDRSTRLEN);
+        port = ntohs (((struct IPv6HttpAddress *) tmp_addr->addr)->u6_port);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Sending message to addres no. %u: `%s':%u\n", count,
+                    address, port);
+      }
+      msg.type = htons (type);
+      memcpy (tmp, &msg, sizeof (struct GNUNET_MessageHeader));
+      api->send (api->cls, &my_identity, tmp,
+                 sizeof (struct GNUNET_MessageHeader), 0, TIMEOUT, NULL,
+                 tmp_addr->addr, tmp_addr->addrlen, GNUNET_YES, &task_send_cont,
+                 &fail_msgs_transmited_to_local_addrs);
       tmp_addr = tmp_addr->next;
 
-      count ++;
-      type ++;
+      count++;
+      type++;
     }
-    GNUNET_free(tmp);
+    GNUNET_free (tmp);
     return;
   }
 
-  if (phase==2)
+  if (phase == 2)
   {
-    struct Session * session = cls;
-    msg = GNUNET_malloc (sizeof(struct GNUNET_MessageHeader));
-
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("\nPhase 2: session selection\n\n"));
-    size = sizeof(struct GNUNET_MessageHeader);
-    msg->size=htons(size);
-    msg->type = htons(20);
-    api->send(api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT, NULL, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
-
-    msg->type = htons(21);
-    api->send(api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT, NULL, NULL, 0, GNUNET_SYSERR, &task_send_cont, NULL);
-
-    /* answer on session*/
-    size = sizeof( struct GNUNET_MessageHeader);
-    msg->size = htons(size);
-    msg->type = htons(22);
-    api->send(api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT, session, NULL, 0, GNUNET_SYSERR, &task_send_cont, NULL);
+    struct Session *session = cls;
 
-    GNUNET_free(msg);
+    msg = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
 
-    /* answer on session with big message not fitting in mhd send buffer*/
-    size = GNUNET_SERVER_MAX_MESSAGE_SIZE-1;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("\nPhase 2: session selection\n\n"));
+    size = sizeof (struct GNUNET_MessageHeader);
+    msg->size = htons (size);
+    msg->type = htons (20);
+    api->send (api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT,
+               NULL, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
+
+    msg->type = htons (21);
+    api->send (api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT,
+               NULL, NULL, 0, GNUNET_SYSERR, &task_send_cont, NULL);
+
+    /* answer on session */
+    size = sizeof (struct GNUNET_MessageHeader);
+    msg->size = htons (size);
+    msg->type = htons (22);
+    api->send (api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT,
+               session, NULL, 0, GNUNET_SYSERR, &task_send_cont, NULL);
+
+    GNUNET_free (msg);
+
+    /* answer on session with big message not fitting in mhd send buffer */
+    size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
     msg = GNUNET_malloc (size);
-    msg->size=htons(size);
-    msg->type = htons(23);
-    api->send(api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT, session, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
-    GNUNET_free(msg);
+    msg->size = htons (size);
+    msg->type = htons (23);
+    api->send (api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT,
+               session, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
+    GNUNET_free (msg);
     return;
   }
 
-  if (phase==3)
+  if (phase == 3)
   {
 
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("\nPhase 3: send multiple or big messages after disconnect\n\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("\nPhase 3: send multiple or big messages after disconnect\n\n"));
     /* disconnect from peer, so new connections are created */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Disconnect from peer: `%s'\n", GNUNET_i2s(&my_identity));
-    api->disconnect(api->cls, &my_identity);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect from peer: `%s'\n",
+                GNUNET_i2s (&my_identity));
+    api->disconnect (api->cls, &my_identity);
 
     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Phase 3: sending messages\n"));
-    /* send a multiple GNUNET_messages at a time*/
-    size = 2 * sizeof(struct GNUNET_MessageHeader);
-    msg = GNUNET_malloc( 2* size);
-    msg->size = htons(size);
-    msg->type = htons(30);
-    struct GNUNET_MessageHeader * msg2 = &msg[2];
-    msg2->size = htons(2 * sizeof(struct GNUNET_MessageHeader));
-    msg2->type = htons(31);
-    api->send(api->cls, &my_identity, (const char *) msg, 4 * sizeof(struct GNUNET_MessageHeader), 0, TIMEOUT, NULL,addr_head->addr, addr_head->addrlen, GNUNET_NO, &task_send_cont, &fail_multiple_msgs_in_transmission);
-    GNUNET_free(msg);
+    /* send a multiple GNUNET_messages at a time */
+    size = 2 * sizeof (struct GNUNET_MessageHeader);
+    msg = GNUNET_malloc (2 * size);
+    msg->size = htons (size);
+    msg->type = htons (30);
+    struct GNUNET_MessageHeader *msg2 = &msg[2];
+
+    msg2->size = htons (2 * sizeof (struct GNUNET_MessageHeader));
+    msg2->type = htons (31);
+    api->send (api->cls, &my_identity, (const char *) msg,
+               4 * sizeof (struct GNUNET_MessageHeader), 0, TIMEOUT, NULL,
+               addr_head->addr, addr_head->addrlen, GNUNET_NO, &task_send_cont,
+               &fail_multiple_msgs_in_transmission);
+    GNUNET_free (msg);
     /* send a message with size GNUNET_SERVER_MAX_MESSAGE_SIZE-1  */
 
-    size = GNUNET_SERVER_MAX_MESSAGE_SIZE-1;
-    msg = GNUNET_malloc(size);
-    msg->size = htons(size);
-    msg->type = htons(32);
-    api->send(api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT, NULL,addr_head->addr, addr_head->addrlen, GNUNET_NO, &task_send_cont, &fail_msg_transmited_max_size);
-    GNUNET_free(msg);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No more tests to run\n");
+    size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
+    msg = GNUNET_malloc (size);
+    msg->size = htons (size);
+    msg->type = htons (32);
+    api->send (api->cls, &my_identity, (const char *) msg, size, 0, TIMEOUT,
+               NULL, addr_head->addr, addr_head->addrlen, GNUNET_NO,
+               &task_send_cont, &fail_msg_transmited_max_size);
+    GNUNET_free (msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No more tests to run\n");
   }
 }
 
@@ -1152,12 +1234,13 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  char * libname;
+  char *libname;
+
   cfg = c;
   char *keyfile;
   unsigned long long tneigh;
-  struct Plugin_Address * cur;
-  const char * addr_str;
+  struct Plugin_Address *cur;
+  const char *addr_str;
   struct stat sbuf;
   unsigned int suggest_res;
 
@@ -1175,8 +1258,9 @@ run (void *cls,
   addr_head = NULL;
   count_str_addr = 0;
   /* parse configuration */
-  if (GNUNET_CONFIGURATION_have_value (c,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (c, "PATHS", "SERVICEHOME", &servicehome);
+  if (GNUNET_CONFIGURATION_have_value (c, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (c, "PATHS", "SERVICEHOME",
+                                           &servicehome);
 
 
   if ((GNUNET_OK !=
@@ -1188,21 +1272,21 @@ run (void *cls,
        GNUNET_CONFIGURATION_get_value_filename (c,
                                                 "GNUNETD",
                                                 "HOSTKEY", &keyfile)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      fail = 1;
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Transport service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    fail = 1;
+    return;
+  }
 
   if ((GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (cfg,
-                                             "transport-https",
-                                             "PORT",
-                                             &port)) ||
-     (port > 65535) || (port == 0))
+       GNUNET_CONFIGURATION_get_value_number (cfg,
+                                              "transport-https",
+                                              "PORT",
+                                              &port)) ||
+      (port > 65535) || (port == 0))
   {
     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                      "https",
@@ -1212,59 +1296,63 @@ run (void *cls,
   }
 
   /* Get private key file from config */
-  if (GNUNET_CONFIGURATION_have_value (cfg,
-                                                                           "transport-https", "KEY_FILE"))
+  if (GNUNET_CONFIGURATION_have_value (cfg, "transport-https", "KEY_FILE"))
   {
-                GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                                                           "transport-https",
-                                                                                           "KEY_FILE",
-                                                                                           &key_file);
+    GNUNET_CONFIGURATION_get_value_string (cfg,
+                                           "transport-https",
+                                           "KEY_FILE", &key_file);
   }
   if (key_file == NULL)
-          GNUNET_asprintf(&key_file,"https.key");
+    GNUNET_asprintf (&key_file, "https.key");
 
-  if (0 == stat (key_file, &sbuf ))
+  if (0 == stat (key_file, &sbuf))
   {
-          if (0 == remove(key_file))
-              GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Successfully removed existing private key file `%s'\n",key_file);
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove private key file `%s'\n",key_file);
+    if (0 == remove (key_file))
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Successfully removed existing private key file `%s'\n",
+                  key_file);
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to remove private key file `%s'\n", key_file);
   }
 
   /* Get private key file from config */
-  if (GNUNET_CONFIGURATION_have_value (cfg,
-                                                                           "transport-https", "CERT_FILE"))
+  if (GNUNET_CONFIGURATION_have_value (cfg, "transport-https", "CERT_FILE"))
   {
-          GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                                                         "transport-https",
-                                                                                     "CERT_FILE",
-                                                                                     &cert_file);
+    GNUNET_CONFIGURATION_get_value_string (cfg,
+                                           "transport-https",
+                                           "CERT_FILE", &cert_file);
   }
   if (cert_file == NULL)
-          GNUNET_asprintf(&cert_file,"https.cert");
+    GNUNET_asprintf (&cert_file, "https.cert");
 
-  if (0 == stat (cert_file, &sbuf ))
+  if (0 == stat (cert_file, &sbuf))
   {
-          if (0 == remove(cert_file))
-              GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Successfully removed existing certificate file `%s'\n",cert_file);
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove existing certificate file `%s'\n",cert_file);
+    if (0 == remove (cert_file))
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Successfully removed existing certificate file `%s'\n",
+                  cert_file);
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to remove existing certificate file `%s'\n",
+                  cert_file);
   }
 
   max_connect_per_transport = (uint32_t) tneigh;
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Transport service could not access hostkey.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      fail = 1;
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    fail = 1;
+    return;
+  }
 
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
-  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_identity.hashPubKey);
+  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
+                      &my_identity.hashPubKey);
 
   /* assertions before start */
   GNUNET_assert ((port > 0) && (port <= 65535));
@@ -1272,7 +1360,8 @@ run (void *cls,
   /* load plugins... */
   setup_plugin_environment ();
   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_https");
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Loading HTTPS transport plugin `%s'\n"),libname);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _("Loading HTTPS transport plugin `%s'\n"), libname);
   api = GNUNET_PLUGIN_load (libname, &env);
   GNUNET_free (libname);
   if (api == NULL)
@@ -1286,46 +1375,52 @@ run (void *cls,
   ti_timeout = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &task_timeout, NULL);
 
   /* testing plugin functionality */
-  GNUNET_assert (0!=fail_notify_address_count);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport plugin returned %u addresses to connect to\n"),  fail_notify_address_count);
+  GNUNET_assert (0 != fail_notify_address_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _("Transport plugin returned %u addresses to connect to\n"),
+              fail_notify_address_count);
 
-  /* testing pretty printer with all addresses obtained from the plugin*/
+  /* testing pretty printer with all addresses obtained from the plugin */
   cur = addr_head;
   while (cur != NULL)
   {
 
-    api->address_pretty_printer (api->cls, "http",cur->addr,cur->addrlen, GNUNET_NO,TEST_TIMEOUT, &pretty_printer_cb,NULL);
+    api->address_pretty_printer (api->cls, "http", cur->addr, cur->addrlen,
+                                 GNUNET_NO, TEST_TIMEOUT, &pretty_printer_cb,
+                                 NULL);
     addr_str = api->address_to_string (api->cls, cur->addr, cur->addrlen);
     suggest_res = api->check_address (api->cls, cur->addr, cur->addrlen);
 
     GNUNET_assert (GNUNET_OK == suggest_res);
     GNUNET_assert (NULL != addr_str);
     count_str_addr++;
-    GNUNET_free ( (char *) addr_str);
+    GNUNET_free ((char *) addr_str);
     cur = cur->next;
   }
   GNUNET_assert (fail_pretty_printer_count > 0);
-  GNUNET_assert (fail_pretty_printer_count==fail_notify_address_count);
-  GNUNET_assert (fail_pretty_printer_count==count_str_addr);
-  fail_pretty_printer=GNUNET_NO;
-  fail_addr_to_str=GNUNET_NO;
+  GNUNET_assert (fail_pretty_printer_count == fail_notify_address_count);
+  GNUNET_assert (fail_pretty_printer_count == count_str_addr);
+  fail_pretty_printer = GNUNET_NO;
+  fail_addr_to_str = GNUNET_NO;
 
   struct IPv4HttpAddress failing_addr;
 
-  /* Suggesting addresses with wrong size*/
-  failing_addr.ipv4_addr = htonl(INADDR_LOOPBACK);
-  failing_addr.u_port = htons(0);
-  suggest_res = api->check_address (api->cls,&failing_addr,sizeof (struct IPv6HttpAddress));
+  /* Suggesting addresses with wrong size */
+  failing_addr.ipv4_addr = htonl (INADDR_LOOPBACK);
+  failing_addr.u_port = htons (0);
+  suggest_res =
+      api->check_address (api->cls, &failing_addr,
+                          sizeof (struct IPv6HttpAddress));
   GNUNET_assert (GNUNET_SYSERR == suggest_res);
 
-  /* Suggesting addresses with wrong address*/
-  failing_addr.ipv4_addr = htonl(0xffc00000);
-  failing_addr.u_port = htons(12389);
-  suggest_res = api->check_address (api->cls,&failing_addr,100);
+  /* Suggesting addresses with wrong address */
+  failing_addr.ipv4_addr = htonl (0xffc00000);
+  failing_addr.u_port = htons (12389);
+  suggest_res = api->check_address (api->cls, &failing_addr, 100);
   GNUNET_assert (GNUNET_SYSERR == suggest_res);
 
   /* test sending to client */
-  multi_handle = curl_multi_init();
+  multi_handle = curl_multi_init ();
 
   /* Setting up buffers */
   buffer_in.size = HTTP_BUFFER_SIZE;
@@ -1354,10 +1449,12 @@ run (void *cls,
   test_valid_ident.test_executed = GNUNET_NO;
   test_valid_ident.test_failed = GNUNET_YES;
 
-  test_addr = (char *) api->address_to_string (api->cls,addr_head->addr,addr_head->addrlen);
+  test_addr =
+      (char *) api->address_to_string (api->cls, addr_head->addr,
+                                       addr_head->addrlen);
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("\nPhase 0\n\n"));
-  run_connection_tests(0, NULL);
+  run_connection_tests (0, NULL);
 
   /* testing finished */
 
@@ -1380,6 +1477,7 @@ main (int argc, char *const *argv)
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
+
   char *const argv_prog[] = {
     "test_gnunet_transport_plugin.https",
     "-c",
@@ -1401,11 +1499,15 @@ main (int argc, char *const *argv)
                     NULL);
 
   struct GNUNET_CONFIGURATION_Handle *cfg;
+
   cfg = GNUNET_CONFIGURATION_create ();
 
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, "test_plugin_transport_data_http.conf"));
-  if (GNUNET_CONFIGURATION_have_value (cfg,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME", &servicehome);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (cfg,
+                                            "test_plugin_transport_data_http.conf"));
+  if (GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME",
+                                           &servicehome);
   GNUNET_DISK_directory_remove (servicehome);
   GNUNET_CONFIGURATION_destroy (cfg);
 
@@ -1413,7 +1515,8 @@ main (int argc, char *const *argv)
          GNUNET_PROGRAM_run (5,
                              argv_prog,
                              "test_gnunet_transport_plugin.https",
-                             "testcase", options, &run, NULL)) ? GNUNET_NO : GNUNET_YES;
+                             "testcase", options, &run,
+                             NULL)) ? GNUNET_NO : GNUNET_YES;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("\ndelete\n\n"));
   if (servicehome != NULL)
   {
diff --git a/src/transport/test_plugin_transport_udp.c b/src/transport/test_plugin_transport_udp.c
index f790ccedc..b23d4eb67 100644
--- a/src/transport/test_plugin_transport_udp.c
+++ b/src/transport/test_plugin_transport_udp.c
@@ -90,11 +90,10 @@ static int ok;
  */
 static void
 receive (void *cls,
-        const struct GNUNET_PeerIdentity * peer,
-        const struct GNUNET_MessageHeader * message,
-        uint32_t distance,
-        const char *sender_address,
-        size_t sender_address_len)
+         const struct GNUNET_PeerIdentity *peer,
+         const struct GNUNET_MessageHeader *message,
+         uint32_t distance,
+         const char *sender_address, size_t sender_address_len)
 {
   /* do nothing */
 }
@@ -118,8 +117,7 @@ static void
 unload_plugins (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (NULL ==
-                 GNUNET_PLUGIN_unload ("libgnunet_plugin_transport_udp",
-                                       api));
+                 GNUNET_PLUGIN_unload ("libgnunet_plugin_transport_udp", api));
   if (my_private_key != NULL)
     GNUNET_CRYPTO_rsa_key_free (my_private_key);
 
@@ -146,10 +144,9 @@ test_validation ()
   soaddr.sin_port = htons (2368 /* FIXME: get from config! */ );
   soaddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 
-  api->check_address(api->cls,
-      &soaddr, sizeof (soaddr));
+  api->check_address (api->cls, &soaddr, sizeof (soaddr));
 
-  unload_plugins(env.cls, env.cfg);
+  unload_plugins (env.cls, env.cfg);
 }
 
 
@@ -190,24 +187,23 @@ run (void *cls,
        GNUNET_CONFIGURATION_get_value_filename (c,
                                                 "GNUNETD",
                                                 "HOSTKEY", &keyfile)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown (s);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Transport service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown (s);
+    return;
+  }
   max_connect_per_transport = (uint32_t) tneigh;
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Transport service could not access hostkey.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown (s);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown (s);
+    return;
+  }
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
   GNUNET_CRYPTO_hash (&my_public_key,
                       sizeof (my_public_key), &my_identity.hashPubKey);
@@ -220,12 +216,12 @@ run (void *cls,
   api = GNUNET_PLUGIN_load (libname, &env);
   GNUNET_free (libname);
   if (api == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to load transport plugin for udp\n"));
-      /* FIXME: set some error code for main */
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to load transport plugin for udp\n"));
+    /* FIXME: set some error code for main */
+    return;
+  }
   test_validation ();
 }
 
@@ -244,6 +240,7 @@ main (int argc, char *const *argv)
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
+
   char *const argv_prog[] = {
     "test_plugin_transport",
     "-c",
diff --git a/src/transport/test_plugin_transport_wlan_dummy.c b/src/transport/test_plugin_transport_wlan_dummy.c
index 173d22bba..eba4f9dbd 100644
--- a/src/transport/test_plugin_transport_wlan_dummy.c
+++ b/src/transport/test_plugin_transport_wlan_dummy.c
@@ -55,76 +55,79 @@
 static int first;
 
 static void
-sigfunc(int sig)
+sigfunc (int sig)
 {
   closeprog = 1;
-  unlink(FIFO_FILE1);
-  unlink(FIFO_FILE2);
+  unlink (FIFO_FILE1);
+  unlink (FIFO_FILE2);
 }
 
 static void
-stdin_send(void *cls, void *client, 
-           const struct GNUNET_MessageHeader *hdr)
+stdin_send (void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
 {
   struct sendbuf *write_pout = cls;
   int sendsize;
   struct GNUNET_MessageHeader newheader;
-  char * to_data;
-  char * to_radiotap;
-  char * to_start;
-
-  sendsize = ntohs(hdr->size) - sizeof(struct Radiotap_Send)
-      + sizeof(struct Radiotap_rx);
-
-  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type))
-    {
-      fprintf(stderr, "Function stdin_send: wrong packet type\n");
-      exit(1);
-    }
+  char *to_data;
+  char *to_radiotap;
+  char *to_start;
+
+  sendsize = ntohs (hdr->size) - sizeof (struct Radiotap_Send)
+      + sizeof (struct Radiotap_rx);
+
+  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs (hdr->type))
+  {
+    fprintf (stderr, "Function stdin_send: wrong packet type\n");
+    exit (1);
+  }
   if ((sendsize + write_pout->size) > MAXLINE * 2)
-    {
-      fprintf(stderr, "Function stdin_send: Packet too big for buffer\n");
-      exit(1);
-    }
+  {
+    fprintf (stderr, "Function stdin_send: Packet too big for buffer\n");
+    exit (1);
+  }
 
-  newheader.size = htons(sendsize);
-  newheader.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
+  newheader.size = htons (sendsize);
+  newheader.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA);
 
   to_start = write_pout->buf + write_pout->size;
-  memcpy(to_start, &newheader, sizeof(struct GNUNET_MessageHeader));
-  write_pout->size += sizeof(struct GNUNET_MessageHeader);
-
-  to_radiotap = to_start + sizeof(struct GNUNET_MessageHeader);
-  memset(to_radiotap, 0, sizeof (struct Radiotap_rx));
-  write_pout->size += sizeof(struct Radiotap_rx);
-
-  to_data = to_radiotap + sizeof(struct Radiotap_rx);
-  memcpy(to_data, 
-         ((char *) hdr) + sizeof(struct Radiotap_Send) + sizeof(struct GNUNET_MessageHeader),
-         ntohs(hdr->size) - sizeof(struct Radiotap_Send) - sizeof(struct GNUNET_MessageHeader));
-  write_pout->size += ntohs(hdr->size) - sizeof(struct Radiotap_Send) - sizeof(struct GNUNET_MessageHeader);
+  memcpy (to_start, &newheader, sizeof (struct GNUNET_MessageHeader));
+  write_pout->size += sizeof (struct GNUNET_MessageHeader);
+
+  to_radiotap = to_start + sizeof (struct GNUNET_MessageHeader);
+  memset (to_radiotap, 0, sizeof (struct Radiotap_rx));
+  write_pout->size += sizeof (struct Radiotap_rx);
+
+  to_data = to_radiotap + sizeof (struct Radiotap_rx);
+  memcpy (to_data,
+          ((char *) hdr) + sizeof (struct Radiotap_Send) +
+          sizeof (struct GNUNET_MessageHeader),
+          ntohs (hdr->size) - sizeof (struct Radiotap_Send) -
+          sizeof (struct GNUNET_MessageHeader));
+  write_pout->size +=
+      ntohs (hdr->size) - sizeof (struct Radiotap_Send) -
+      sizeof (struct GNUNET_MessageHeader);
 }
 
 static void
-file_in_send(void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
+file_in_send (void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
 {
-  struct sendbuf * write_std = cls;
+  struct sendbuf *write_std = cls;
   uint16_t sendsize;
 
-  sendsize = ntohs(hdr->size);
+  sendsize = ntohs (hdr->size);
 
-  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type))
-    {
-      fprintf(stderr, "Function file_in_send: wrong packet type\n");
-      exit(1);
-    }
+  if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs (hdr->type))
+  {
+    fprintf (stderr, "Function file_in_send: wrong packet type\n");
+    exit (1);
+  }
   if ((sendsize + write_std->size) > MAXLINE * 2)
-    {
-      fprintf(stderr, "Function file_in_send: Packet too big for buffer\n");
-      exit(1);
-    }
+  {
+    fprintf (stderr, "Function file_in_send: Packet too big for buffer\n");
+    exit (1);
+  }
 
-  memcpy(write_std->buf + write_std->size, hdr, sendsize);
+  memcpy (write_std->buf + write_std->size, hdr, sendsize);
   write_std->size += sendsize;
 }
 
@@ -132,7 +135,7 @@ int closeprog;
 
 
 int
-testmode(int argc, char *argv[])
+testmode (int argc, char *argv[])
 {
   struct stat st;
   int erg;
@@ -144,111 +147,113 @@ testmode(int argc, char *argv[])
   int fdpout;
 
   //make the fifos if needed
-  if (0 != stat(FIFO_FILE1, &st))
+  if (0 != stat (FIFO_FILE1, &st))
+  {
+    if (0 == stat (FIFO_FILE2, &st))
     {
-      if (0 == stat(FIFO_FILE2, &st))
-        {
-          fprintf(stderr, "FIFO_FILE2 exists, but FIFO_FILE1 not\n");
-          exit(1);
-        }
-
-      umask(0);
-      //unlink(FIFO_FILE1);
-      //unlink(FIFO_FILE2);
-      // FIXME: use mkfifo!
-     erg = mknod(FIFO_FILE1, S_IFIFO | 0666, 0);
-      if (0 != erg)
-        {
-          fprintf(stderr, "Error at mknode1 \n");
-          //exit(1);
-        }
-      erg = mknod(FIFO_FILE2, S_IFIFO | 0666, 0);
-      if (0 != erg)
-        {
-          fprintf(stderr, "Error at mknode2 \n");
-          //exit(1);
-        }
+      fprintf (stderr, "FIFO_FILE2 exists, but FIFO_FILE1 not\n");
+      exit (1);
+    }
 
+    umask (0);
+    //unlink(FIFO_FILE1);
+    //unlink(FIFO_FILE2);
+    // FIXME: use mkfifo!
+    erg = mknod (FIFO_FILE1, S_IFIFO | 0666, 0);
+    if (0 != erg)
+    {
+      fprintf (stderr, "Error at mknode1 \n");
+      //exit(1);
     }
-  else
+    erg = mknod (FIFO_FILE2, S_IFIFO | 0666, 0);
+    if (0 != erg)
     {
+      fprintf (stderr, "Error at mknode2 \n");
+      //exit(1);
+    }
 
-      if (0 != stat(FIFO_FILE2, &st))
-        {
-          fprintf(stderr, "FIFO_FILE1 exists, but FIFO_FILE2 not\n");
-          exit(1);
-        }
+  }
+  else
+  {
 
+    if (0 != stat (FIFO_FILE2, &st))
+    {
+      fprintf (stderr, "FIFO_FILE1 exists, but FIFO_FILE2 not\n");
+      exit (1);
     }
 
-  if (strstr(argv[1], "1"))
-    {
-      //fprintf(stderr, "First\n");
-      first = 1;
-      fpin = fopen(FIFO_FILE1, "r");
-      if (NULL == fpin)
-        {
-          fprintf(stderr, "fopen of read FIFO_FILE1\n");
-          goto end;
-        }
-      fpout = fopen(FIFO_FILE2, "w");
-      if (NULL == fpout)
-        {
-          fprintf(stderr, "fopen of write FIFO_FILE2\n");
-          goto end;
-        }
+  }
 
+  if (strstr (argv[1], "1"))
+  {
+    //fprintf(stderr, "First\n");
+    first = 1;
+    fpin = fopen (FIFO_FILE1, "r");
+    if (NULL == fpin)
+    {
+      fprintf (stderr, "fopen of read FIFO_FILE1\n");
+      goto end;
     }
-  else
+    fpout = fopen (FIFO_FILE2, "w");
+    if (NULL == fpout)
     {
-      first = 0;
-      //fprintf(stderr, "Second\n");
-      fpout = fopen(FIFO_FILE1, "w");
-      if (NULL == fpout)
-        {
-          fprintf(stderr, "fopen of write FIFO_FILE1\n");
-          goto end;
-        }
-      fpin = fopen(FIFO_FILE2, "r");
-      if (NULL == fpin)
-        {
-          fprintf(stderr, "fopen of read FIFO_FILE2\n");
-          goto end;
-        }
-
+      fprintf (stderr, "fopen of write FIFO_FILE2\n");
+      goto end;
     }
 
-  fdpin = fileno(fpin);
-  GNUNET_assert(fpin >= 0);
-
-  if (fdpin >= FD_SETSIZE)
+  }
+  else
+  {
+    first = 0;
+    //fprintf(stderr, "Second\n");
+    fpout = fopen (FIFO_FILE1, "w");
+    if (NULL == fpout)
     {
-      fprintf(stderr, "File fdpin number too large (%d > %u)\n", fdpin,
-          (unsigned int) FD_SETSIZE);
+      fprintf (stderr, "fopen of write FIFO_FILE1\n");
       goto end;
     }
+    fpin = fopen (FIFO_FILE2, "r");
+    if (NULL == fpin)
+    {
+      fprintf (stderr, "fopen of read FIFO_FILE2\n");
+      goto end;
+    }
+
+  }
+
+  fdpin = fileno (fpin);
+  GNUNET_assert (fpin >= 0);
+
+  if (fdpin >= FD_SETSIZE)
+  {
+    fprintf (stderr, "File fdpin number too large (%d > %u)\n", fdpin,
+             (unsigned int) FD_SETSIZE);
+    goto end;
+  }
 
-  fdpout = fileno(fpout);
-  GNUNET_assert(fdpout >= 0 );
+  fdpout = fileno (fpout);
+  GNUNET_assert (fdpout >= 0);
 
   if (fdpout >= FD_SETSIZE)
-    {
-      fprintf(stderr, "File fdpout number too large (%d > %u)\n", fdpout,
-          (unsigned int) FD_SETSIZE);
-      goto end;
+  {
+    fprintf (stderr, "File fdpout number too large (%d > %u)\n", fdpout,
+             (unsigned int) FD_SETSIZE);
+    goto end;
 
-    }
+  }
 
-  signal(SIGINT, &sigfunc);
-  signal(SIGTERM, &sigfunc);
+  signal (SIGINT, &sigfunc);
+  signal (SIGTERM, &sigfunc);
 
   char readbuf[MAXLINE];
   int readsize = 0;
   struct sendbuf write_std;
+
   write_std.size = 0;
   write_std.pos = 0;
 
   struct sendbuf write_pout;
+
   write_pout.size = 0;
   write_pout.pos = 0;
 
@@ -260,11 +265,11 @@ testmode(int argc, char *argv[])
   struct timeval tv;
   int retval;
 
-  struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst;
-  struct GNUNET_SERVER_MessageStreamTokenizer * file_in_mst;
+  struct GNUNET_SERVER_MessageStreamTokenizer *stdin_mst;
+  struct GNUNET_SERVER_MessageStreamTokenizer *file_in_mst;
 
-  stdin_mst = GNUNET_SERVER_mst_create(&stdin_send, &write_pout);
-  file_in_mst = GNUNET_SERVER_mst_create(&file_in_send, &write_std);
+  stdin_mst = GNUNET_SERVER_mst_create (&stdin_send, &write_pout);
+  file_in_mst = GNUNET_SERVER_mst_create (&file_in_send, &write_std);
 
   //send mac first
 
@@ -275,187 +280,185 @@ testmode(int argc, char *argv[])
   macaddr.mac[1] = 0x22;
   macaddr.mac[2] = 0x33;
   macaddr.mac[3] = 0x44;
-  macaddr.mac[4] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 256);
-  macaddr.mac[5] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, 256);
+  macaddr.mac[4] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 256);
+  macaddr.mac[5] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, 256);
 
-  write_std.size = send_mac_to_plugin(write_std.buf, macaddr.mac);
+  write_std.size = send_mac_to_plugin (write_std.buf, macaddr.mac);
 
   while (0 == closeprog)
-    {
-
-      maxfd = 0;
+  {
 
-      //set timeout
-      tv.tv_sec = 5;
-      tv.tv_usec = 0;
+    maxfd = 0;
 
-      FD_ZERO(&rfds);
-      // if output queue is empty
-      if (0 == write_pout.size)
-        {
-          FD_SET(STDIN_FILENO, &rfds);
+    //set timeout
+    tv.tv_sec = 5;
+    tv.tv_usec = 0;
 
-        }
-      if (0 == write_std.size)
-        {
-          FD_SET(fdpin, &rfds);
-          maxfd = fdpin;
-        }
-      FD_ZERO(&wfds);
-      // if there is something to write
-      if (0 < write_std.size)
-        {
-          FD_SET(STDOUT_FILENO, &wfds);
-          maxfd = MAX(maxfd, STDOUT_FILENO);
-        }
+    FD_ZERO (&rfds);
+    // if output queue is empty
+    if (0 == write_pout.size)
+    {
+      FD_SET (STDIN_FILENO, &rfds);
 
-      if (0 < write_pout.size)
-        {
-          FD_SET(fdpout, &wfds);
-          maxfd = MAX(maxfd, fdpout);
-        }
+    }
+    if (0 == write_std.size)
+    {
+      FD_SET (fdpin, &rfds);
+      maxfd = fdpin;
+    }
+    FD_ZERO (&wfds);
+    // if there is something to write
+    if (0 < write_std.size)
+    {
+      FD_SET (STDOUT_FILENO, &wfds);
+      maxfd = MAX (maxfd, STDOUT_FILENO);
+    }
 
-      retval = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
+    if (0 < write_pout.size)
+    {
+      FD_SET (fdpout, &wfds);
+      maxfd = MAX (maxfd, fdpout);
+    }
 
-      if (-1 == retval && EINTR == errno)
-        {
-          continue;
-        }
-      if (0 > retval)
-        {
-          fprintf(stderr, "select failed: %s\n", strerror(errno));
-          closeprog = 1;
-          break;
-        }
+    retval = select (maxfd + 1, &rfds, &wfds, NULL, &tv);
 
-      if (FD_ISSET(STDOUT_FILENO, &wfds))
-        {
-          ret = write(STDOUT_FILENO, 
-                      write_std.buf + write_std.pos,
-                      write_std.size - write_std.pos);
-          if (0 > ret)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Write ERROR to STDOUT\n");
-              break;
-            }
-          else
-            {
-              write_std.pos += ret;
-              // check if finished
-              if (write_std.pos == write_std.size)
-                {
-                  write_std.pos = 0;
-                  write_std.size = 0;
-                }
-            }
-        }
+    if (-1 == retval && EINTR == errno)
+    {
+      continue;
+    }
+    if (0 > retval)
+    {
+      fprintf (stderr, "select failed: %s\n", strerror (errno));
+      closeprog = 1;
+      break;
+    }
 
-      if (FD_ISSET(fdpout, &wfds))
+    if (FD_ISSET (STDOUT_FILENO, &wfds))
+    {
+      ret = write (STDOUT_FILENO,
+                   write_std.buf + write_std.pos,
+                   write_std.size - write_std.pos);
+      if (0 > ret)
+      {
+        closeprog = 1;
+        fprintf (stderr, "Write ERROR to STDOUT\n");
+        break;
+      }
+      else
+      {
+        write_std.pos += ret;
+        // check if finished
+        if (write_std.pos == write_std.size)
         {
-          ret = write(fdpout,
-                      write_pout.buf + write_pout.pos, 
-                      write_pout.size - write_pout.pos);
-          
-          if (0 > ret)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Write ERROR to fdpout\n");
-            }
-          else
-            {
-              write_pout.pos += ret;
-              // check if finished
-              if (write_pout.pos == write_pout.size)
-                {
-                  write_pout.pos = 0;
-                  write_pout.size = 0;
-                }
-            }
+          write_std.pos = 0;
+          write_std.size = 0;
         }
+      }
+    }
 
-      if (FD_ISSET(STDIN_FILENO, &rfds))
+    if (FD_ISSET (fdpout, &wfds))
+    {
+      ret = write (fdpout,
+                   write_pout.buf + write_pout.pos,
+                   write_pout.size - write_pout.pos);
+
+      if (0 > ret)
+      {
+        closeprog = 1;
+        fprintf (stderr, "Write ERROR to fdpout\n");
+      }
+      else
+      {
+        write_pout.pos += ret;
+        // check if finished
+        if (write_pout.pos == write_pout.size)
         {
-          readsize = read(STDIN_FILENO, readbuf, sizeof(readbuf));
-
-          if (0 > readsize)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Read ERROR to STDIN_FILENO\n");
-            }
-          else if (0 < readsize)
-            {
-              GNUNET_SERVER_mst_receive(stdin_mst, NULL, readbuf, readsize,
-                  GNUNET_NO, GNUNET_NO);
-
-            }
-          else
-            {
-              //eof
-              closeprog = 1;
-            }
+          write_pout.pos = 0;
+          write_pout.size = 0;
         }
+      }
+    }
 
-      if (FD_ISSET(fdpin, &rfds))
-        {
-          readsize = read(fdpin, readbuf, sizeof(readbuf));
-
-          if (0 > readsize)
-            {
-              closeprog = 1;
-              fprintf(stderr, "Read ERROR to fdpin: %s\n", strerror(errno));
-              break;
-            }
-          else if (0 < readsize)
-            {
-              GNUNET_SERVER_mst_receive(file_in_mst, NULL, readbuf, readsize,
-                  GNUNET_NO, GNUNET_NO);
-
-            }
-          else
-            {
-              //eof
-              closeprog = 1;
-            }
-        }
+    if (FD_ISSET (STDIN_FILENO, &rfds))
+    {
+      readsize = read (STDIN_FILENO, readbuf, sizeof (readbuf));
+
+      if (0 > readsize)
+      {
+        closeprog = 1;
+        fprintf (stderr, "Read ERROR to STDIN_FILENO\n");
+      }
+      else if (0 < readsize)
+      {
+        GNUNET_SERVER_mst_receive (stdin_mst, NULL, readbuf, readsize,
+                                   GNUNET_NO, GNUNET_NO);
+
+      }
+      else
+      {
+        //eof
+        closeprog = 1;
+      }
+    }
 
+    if (FD_ISSET (fdpin, &rfds))
+    {
+      readsize = read (fdpin, readbuf, sizeof (readbuf));
+
+      if (0 > readsize)
+      {
+        closeprog = 1;
+        fprintf (stderr, "Read ERROR to fdpin: %s\n", strerror (errno));
+        break;
+      }
+      else if (0 < readsize)
+      {
+        GNUNET_SERVER_mst_receive (file_in_mst, NULL, readbuf, readsize,
+                                   GNUNET_NO, GNUNET_NO);
+
+      }
+      else
+      {
+        //eof
+        closeprog = 1;
+      }
     }
 
+  }
+
   //clean up
 
-  GNUNET_SERVER_mst_destroy(stdin_mst);
-  GNUNET_SERVER_mst_destroy(file_in_mst);
+  GNUNET_SERVER_mst_destroy (stdin_mst);
+  GNUNET_SERVER_mst_destroy (file_in_mst);
 
-  end: if (fpout != NULL)
-    fclose(fpout);
+end:if (fpout != NULL)
+    fclose (fpout);
   if (fpin != NULL)
-    fclose(fpin);
+    fclose (fpin);
 
   if (1 == first)
-    {
-      unlink(FIFO_FILE1);
-      unlink(FIFO_FILE2);
-    }
+  {
+    unlink (FIFO_FILE1);
+    unlink (FIFO_FILE2);
+  }
 
   return (0);
 }
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   if (2 != argc)
-    {
-      fprintf (stderr,
-               "This program must be started with the operating mode as argument.\n");
-      fprintf (stderr,
-               "Usage: options\n"
-               "options:\n"
-               "1 = first loopback file\n"
-               "2 = second loopback file\n"
-               "\n");
-      return 1;
-    }
-  if (strstr(argv[1], "1") || strstr(argv[1], "2"))
-    return testmode(argc, argv);
+  {
+    fprintf (stderr,
+             "This program must be started with the operating mode as argument.\n");
+    fprintf (stderr,
+             "Usage: options\n"
+             "options:\n"
+             "1 = first loopback file\n" "2 = second loopback file\n" "\n");
+    return 1;
+  }
+  if (strstr (argv[1], "1") || strstr (argv[1], "2"))
+    return testmode (argc, argv);
   return 1;
 }
diff --git a/src/transport/test_quota_compliance.c b/src/transport/test_quota_compliance.c
index 921fa9542..e4638e4fc 100644
--- a/src/transport/test_quota_compliance.c
+++ b/src/transport/test_quota_compliance.c
@@ -141,7 +141,7 @@ static GNUNET_SCHEDULER_TaskIdentifier tct;
 static GNUNET_SCHEDULER_TaskIdentifier measurement_task;
 static GNUNET_SCHEDULER_TaskIdentifier measurement_counter_task;
 
-static struct GNUNET_TRANSPORT_TransmitHandle * transmit_handle;
+static struct GNUNET_TRANSPORT_TransmitHandle *transmit_handle;
 
 #define OKPP do { ok++; } while (0)
 
@@ -151,28 +151,27 @@ end ()
 {
   GNUNET_SCHEDULER_cancel (die_task);
   die_task = GNUNET_SCHEDULER_NO_TASK;
-  
+
   if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (measurement_task);
-      measurement_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (measurement_task);
+    measurement_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (measurement_counter_task);
-      measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  fprintf(stderr,"\n");
+  {
+    GNUNET_SCHEDULER_cancel (measurement_counter_task);
+    measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  fprintf (stderr, "\n");
   GNUNET_SCHEDULER_shutdown ();
 #if DEBUG_CONNECTIONS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting from transports!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
 #endif
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transports disconnected, returning success!\n");
+              "Transports disconnected, returning success!\n");
 #endif
   GNUNET_SCHEDULER_shutdown ();
 }
@@ -194,8 +193,7 @@ stop_arm (struct PeerContext *p)
 
 
 static void
-end_badly (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
   {
@@ -203,16 +201,16 @@ end_badly (void *cls,
     measurement_task = GNUNET_SCHEDULER_NO_TASK;
   }
   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (measurement_counter_task);
-      measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (measurement_counter_task);
+    measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_break (0);
   if (GNUNET_SCHEDULER_NO_TASK != tct)
-    {
-      GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (p1.th != NULL)
     GNUNET_TRANSPORT_disconnect (p1.th);
   if (p2.th != NULL)
@@ -235,32 +233,32 @@ get_size ()
 
 static void
 notify_receive_new (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
+                    const struct GNUNET_PeerIdentity *peer,
+                    const struct GNUNET_MessageHeader *message,
+                    const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                    uint32_t ats_count)
 {
   const struct TestMessage *hdr;
 
   GNUNET_assert (message != NULL);
-  hdr = (const struct TestMessage*) message;
+  hdr = (const struct TestMessage *) message;
   if (measurement_running == GNUNET_NO)
-          return;
+    return;
   if (MTYPE != ntohs (message->type))
     return;
 
 #if DEBUG_MEASUREMENT
-  if (ntohl(hdr->num) % 5000 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Got message %u of size %u\n",
-                  ntohl (hdr->num),
-                  ntohs (message->size));
-    }
+  if (ntohl (hdr->num) % 5000 == 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got message %u of size %u\n",
+                ntohl (hdr->num), ntohs (message->size));
+  }
 #endif
   /*
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got message %u\n",
-              ntohl (hdr->num));*/
+   * GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+   * "Got message %u\n",
+   * ntohl (hdr->num)); */
   last_msg_recv = ntohl (hdr->num);
 }
 
@@ -278,15 +276,15 @@ notify_ready (void *cls, size_t size, void *buf)
     return 0;
 
   if (buf == NULL)
-    {
-      ok = 42;
-      return 0;
-    }
+  {
+    ok = 42;
+    return 0;
+  }
   if (measurement_running != GNUNET_YES)
-    {
-      send_running = GNUNET_NO;
-      return 0;
-    }
+  {
+    send_running = GNUNET_NO;
+    return 0;
+  }
   send_running = GNUNET_YES;
   ret = 0;
   s = get_size ();
@@ -295,271 +293,268 @@ notify_ready (void *cls, size_t size, void *buf)
   last_msg_sent++;
   cbuf = buf;
   do
-    {
-      hdr.header.size = htons (s);
-      hdr.header.type = htons (MTYPE);
-      hdr.num = htonl (last_msg_sent);
-      memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
-      ret += sizeof (struct TestMessage);
-      memset (&cbuf[ret], last_msg_sent, s - sizeof (struct TestMessage));
-      ret += s - sizeof (struct TestMessage);
+  {
+    hdr.header.size = htons (s);
+    hdr.header.type = htons (MTYPE);
+    hdr.num = htonl (last_msg_sent);
+    memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+    ret += sizeof (struct TestMessage);
+    memset (&cbuf[ret], last_msg_sent, s - sizeof (struct TestMessage));
+    ret += s - sizeof (struct TestMessage);
 #if DEBUG_MEASUREMENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending message %u\n",
-                  last_msg_sent);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message %u\n", last_msg_sent);
 #endif
-      s = get_size ();
-      if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
-        break; /* sometimes pack buffer full, sometimes not */
-    }
+    s = get_size ();
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+      break;                    /* sometimes pack buffer full, sometimes not */
+  }
   while (size - ret >= s);
   transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                            &p1.id,
-                                            s, 0, SEND_TIMEOUT,
-                                            &notify_ready,
-                                            NULL);
+                                                            &p1.id,
+                                                            s, 0, SEND_TIMEOUT,
+                                                            &notify_ready,
+                                                            NULL);
   total_bytes_sent += s;
   return ret;
 }
 
 
-static void
-measure (unsigned long long quota_p1, unsigned long long quota_p2);
+static void measure (unsigned long long quota_p1, unsigned long long quota_p2);
 
-static void 
-measurement_counter (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+measurement_counter (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
-  
-  fprintf(stderr,".");
-  measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                                           &measurement_counter,
-                                                           NULL);
+
+  fprintf (stderr, ".");
+  measurement_counter_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                    &measurement_counter, NULL);
 }
 
 
 static void
-measurement_end (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+measurement_end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   static int strike_counter;
   static int failed_measurement_counter = 1;
-  unsigned long long  quota_allowed = 0;
+  unsigned long long quota_allowed = 0;
   int delta = 0;
 
-  measurement_task  = GNUNET_SCHEDULER_NO_TASK;
+  measurement_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
   measurement_running = GNUNET_NO;
   struct GNUNET_TIME_Relative duration
-    = GNUNET_TIME_absolute_get_difference(start_time, GNUNET_TIME_absolute_get());
+      = GNUNET_TIME_absolute_get_difference (start_time,
+                                             GNUNET_TIME_absolute_get ());
 
 
   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (measurement_counter_task);
-      measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  
+  {
+    GNUNET_SCHEDULER_cancel (measurement_counter_task);
+    measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+
   if (transmit_handle != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
-      transmit_handle = NULL;
-    }
-  
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (transmit_handle);
+    transmit_handle = NULL;
+  }
+
   if (current_quota_p1 < current_quota_p2)
     quota_allowed = current_quota_p1;
   else
     quota_allowed = current_quota_p2;
-  
-  
-  if (MEASUREMENT_SOFT_LIMIT > (quota_allowed/3))
+
+
+  if (MEASUREMENT_SOFT_LIMIT > (quota_allowed / 3))
     delta = MEASUREMENT_SOFT_LIMIT;
   else
-    delta = (quota_allowed/3);
-  
+    delta = (quota_allowed / 3);
+
   /* Throughput is far too slow. This is to prevent the test to exit with success when throughput is 0 */
-  if ((total_bytes_sent/(duration.rel_value / 1000)) < 100)
+  if ((total_bytes_sent / (duration.rel_value / 1000)) < 100)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "\nQuota compliance failed: \n"
+                "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"
+                "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"
+                "Throughput              : %10llu kB/s (%llu B/s)\n",
+                (quota_allowed / (1024)), quota_allowed,
+                ((quota_allowed + delta) / (1024)), quota_allowed + delta,
+                (total_bytes_sent / (duration.rel_value / 1000) / 1024),
+                total_bytes_sent / (duration.rel_value / 1000));
+    ok = 1;
+    failed_measurement_counter--;
+    if (failed_measurement_counter < 0)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "\nQuota compliance failed: \n"                       \
-                  "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
-                  "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
-                  "Throughput              : %10llu kB/s (%llu B/s)\n",
-                  (quota_allowed / (1024)), quota_allowed,
-                  ((quota_allowed+delta) / (1024)),  quota_allowed+delta,
-                  (total_bytes_sent/(duration.rel_value / 1000)/1024),
-                  total_bytes_sent/(duration.rel_value / 1000));
-      ok = 1;
-      failed_measurement_counter--;
-      if (failed_measurement_counter < 0)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      "\nQuota measurement failed and no free strike: %i\n",
-                      failed_measurement_counter);
-          end();
-          return;
-        }
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "\nQuota measurement failed and %i free strikes\n",
-                    failed_measurement_counter);
+                  "\nQuota measurement failed and no free strike: %i\n",
+                  failed_measurement_counter);
+      end ();
+      return;
     }
-  
-  /* Throughput is bigger than allowed quota + some extra*/
-  if ((total_bytes_sent/(duration.rel_value / 1000)) > (quota_allowed + delta))
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "\nQuota measurement failed and %i free strikes\n",
+                  failed_measurement_counter);
+  }
+
+  /* Throughput is bigger than allowed quota + some extra */
+  if ((total_bytes_sent / (duration.rel_value / 1000)) >
+      (quota_allowed + delta))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "\nQuota compliance failed: \n"
+                "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"
+                "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"
+                "Throughput              : %10llu kB/s (%llu B/s)\n",
+                (quota_allowed / (1024)), quota_allowed,
+                ((quota_allowed + delta) / (1024)), quota_allowed + delta,
+                (total_bytes_sent / (duration.rel_value / 1000) / 1024),
+                total_bytes_sent / (duration.rel_value / 1000));
+    ok = 1;
+    failed_measurement_counter--;
+    if (failed_measurement_counter < 0)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "\nQuota compliance failed: \n"                       \
-                  "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
-                  "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
-                  "Throughput              : %10llu kB/s (%llu B/s)\n", 
-                  (quota_allowed / (1024)), quota_allowed, 
-                  ((quota_allowed+delta) / (1024)),  quota_allowed+delta, 
-                  (total_bytes_sent/(duration.rel_value / 1000)/1024), 
-                  total_bytes_sent/(duration.rel_value / 1000));
-      ok = 1;
-      failed_measurement_counter--;
-      if (failed_measurement_counter < 0)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      "\nQuota measurement failed and no free strike: %i\n",failed_measurement_counter);
-          end();
-          return;
-        }
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "\nQuota measurement failed and %i free strikes\n",failed_measurement_counter);
+                  "\nQuota measurement failed and no free strike: %i\n",
+                  failed_measurement_counter);
+      end ();
+      return;
     }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "\nQuota measurement failed and %i free strikes\n",
+                  failed_measurement_counter);
+  }
   else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "\nQuota compliance ok: \n"
+                "Quota allowed: %10llu kB/s\n"
+                "Throughput   : %10llu kB/s\n",
+                (quota_allowed / (1024)),
+                (total_bytes_sent / (duration.rel_value / 1000) / 1024));
+    if (failed_measurement_counter < 2)
+      failed_measurement_counter++;
+    ok = 0;
+  }
+
+  if ((quota_allowed) > (2 * (total_bytes_sent / (duration.rel_value / 1000))))
+  {
+    if (failed_measurement_counter < 2)
+      failed_measurement_counter++;
+    if (strike_counter == 2)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "\nQuota compliance ok: \n"                   \
-                  "Quota allowed: %10llu kB/s\n"                        \
-                  "Throughput   : %10llu kB/s\n",
-                  (quota_allowed / (1024)), 
-                  (total_bytes_sent/(duration.rel_value / 1000)/1024));
-      if (failed_measurement_counter < 2)
-        failed_measurement_counter++;
-      ok = 0;
-    }
-  
-  if ((quota_allowed) > (2 *(total_bytes_sent/(duration.rel_value / 1000))))
-    {
-      if (failed_measurement_counter < 2)
-        failed_measurement_counter++;
-      if (strike_counter == 2)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      "Maximum transmission rate reached, stopping test\n");
-          end();
-          return;
-        }
+                  "Maximum transmission rate reached, stopping test\n");
+      end ();
+      return;
     }
+  }
   else
-    {
-      strike_counter = 0;
-    }
-  
+  {
+    strike_counter = 0;
+  }
+
   if (quota_allowed == MEASUREMENT_MAX_QUOTA)
-    {
-      end();
-      return;
-    }
+  {
+    end ();
+    return;
+  }
   if (is_asymmetric_send_constant == GNUNET_YES)
-    {
-      if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
-        measure (current_quota_p1 * 2, MEASUREMENT_MAX_QUOTA);
-      else
-        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
-    }
+  {
+    if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
+      measure (current_quota_p1 * 2, MEASUREMENT_MAX_QUOTA);
+    else
+      measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
+  }
   else if (is_asymmetric_recv_constant == GNUNET_YES)
-    {
-      if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
-        measure (MEASUREMENT_MAX_QUOTA, current_quota_p2 * 2);
-      else
-        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
-    }
+  {
+    if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
+      measure (MEASUREMENT_MAX_QUOTA, current_quota_p2 * 2);
+    else
+      measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
+  }
   else
-    {
-      if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
-        measure ((current_quota_p1) * 2, (current_quota_p2) * 2);
-      else
-        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
-    }
+  {
+    if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
+      measure ((current_quota_p1) * 2, (current_quota_p2) * 2);
+    else
+      measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
+  }
 }
 
-static void 
+static void
 measure (unsigned long long quota_p1, unsigned long long quota_p2)
 {
   current_quota_p1 = quota_p1;
   current_quota_p2 = quota_p2;
 #if VERBOSE
-  if ((is_asymmetric_send_constant == GNUNET_YES) || (is_asymmetric_recv_constant == GNUNET_YES))
+  if ((is_asymmetric_send_constant == GNUNET_YES) ||
+      (is_asymmetric_recv_constant == GNUNET_YES))
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Starting transport level measurement for %u seconds, receiving peer quota %llu kB/s, sending peer quota %llu kB/s\n",
-                MEASUREMENT_INTERVALL.rel_value / 1000 ,
-                current_quota_p1 / 1024,
-                current_quota_p2 / 1024);
+                "Starting transport level measurement for %u seconds, receiving peer quota %llu kB/s, sending peer quota %llu kB/s\n",
+                MEASUREMENT_INTERVALL.rel_value / 1000, current_quota_p1 / 1024,
+                current_quota_p2 / 1024);
   else
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Starting transport level measurement for %u seconds, symmetric quota %llu kB/s\n", 
-                MEASUREMENT_INTERVALL.rel_value / 1000,
-                current_quota_p2 / 1024);
-  
+                "Starting transport level measurement for %u seconds, symmetric quota %llu kB/s\n",
+                MEASUREMENT_INTERVALL.rel_value / 1000,
+                current_quota_p2 / 1024);
+
 #endif
   GNUNET_TRANSPORT_set_quota (p1.th,
-                              &p2.id,
-                              GNUNET_BANDWIDTH_value_init (current_quota_p1),
-                              GNUNET_BANDWIDTH_value_init (current_quota_p1));
+                              &p2.id,
+                              GNUNET_BANDWIDTH_value_init (current_quota_p1),
+                              GNUNET_BANDWIDTH_value_init (current_quota_p1));
   GNUNET_TRANSPORT_set_quota (p2.th,
-                              &p1.id,
-                              GNUNET_BANDWIDTH_value_init (current_quota_p2),
-                              GNUNET_BANDWIDTH_value_init (current_quota_p2));
+                              &p1.id,
+                              GNUNET_BANDWIDTH_value_init (current_quota_p2),
+                              GNUNET_BANDWIDTH_value_init (current_quota_p2));
   GNUNET_SCHEDULER_cancel (die_task);
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly,
-                                           NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (measurement_counter_task);
-  measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                                           &measurement_counter,
-                                                           NULL);
-  measurement_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
-                                                   &measurement_end,
-                                                   NULL);
+  measurement_counter_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                    &measurement_counter, NULL);
+  measurement_task =
+      GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL, &measurement_end,
+                                    NULL);
   total_bytes_sent = 0;
   last_msg_sent = 0;
   last_msg_recv = 0;
   measurement_running = GNUNET_YES;
   start_time = GNUNET_TIME_absolute_get ();
-  
+
   if (transmit_handle != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (transmit_handle);
   transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                                            &p1.id,
-                                                            get_size (), 0, SEND_TIMEOUT,
-                                                            &notify_ready,
-                                                            NULL);
+                                                            &p1.id,
+                                                            get_size (), 0,
+                                                            SEND_TIMEOUT,
+                                                            &notify_ready,
+                                                            NULL);
 }
 
 
 static void
-exchange_hello_last (void *cls,
-                     const struct GNUNET_MessageHeader *message)
+exchange_hello_last (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
   GNUNET_assert (message != NULL);
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d with peer (%s)!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d with peer (%s)!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
 #endif
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
@@ -570,8 +565,7 @@ exchange_hello_last (void *cls,
 
 
 static void
-exchange_hello (void *cls,
-                const struct GNUNET_MessageHeader *message)
+exchange_hello (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
@@ -581,9 +575,9 @@ exchange_hello (void *cls,
                                       message, &me->id));
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d from peer %s!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d from peer %s!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
 #endif
   GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 }
@@ -592,43 +586,40 @@ exchange_hello (void *cls,
 static void
 notify_connect (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
-{ 
+                const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                uint32_t ats_count)
+{
   connected++;
- if (cls == &p1)
-    {
+  if (cls == &p1)
+  {
 #if DEBUG_CONNECTIONS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Peer 1 `%4s' connected to us (%p)!\n", 
-                  GNUNET_i2s (peer), 
-                  cls);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer 1 `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
 #endif
-    }
+  }
   else
-    {
+  {
 #if DEBUG_CONNECTIONS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Peer 2 `%4s' connected to us (%p)!\n", 
-                  GNUNET_i2s (peer), 
-                  cls);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer 2 `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
 #endif
-    }
+  }
   if (connected == 2)
+  {
+    if (GNUNET_SCHEDULER_NO_TASK != tct)
     {
-      if (GNUNET_SCHEDULER_NO_TASK != tct)
-        {
-          GNUNET_SCHEDULER_cancel (tct);
-          tct = GNUNET_SCHEDULER_NO_TASK;
-        }
-      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
-      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
-      if (is_asymmetric_send_constant == GNUNET_YES)
-        measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MAX_QUOTA);
-      else if (is_asymmetric_recv_constant == GNUNET_YES)
-        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MIN_QUOTA);
-      else
-        measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MIN_QUOTA);
+      GNUNET_SCHEDULER_cancel (tct);
+      tct = GNUNET_SCHEDULER_NO_TASK;
     }
+    GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
+    GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
+    if (is_asymmetric_send_constant == GNUNET_YES)
+      measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MAX_QUOTA);
+    else if (is_asymmetric_recv_constant == GNUNET_YES)
+      measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MIN_QUOTA);
+    else
+      measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MIN_QUOTA);
+  }
 }
 
 
@@ -636,18 +627,17 @@ static void
 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   if (cls == &p2)
+  {
+    if (NULL != transmit_handle)
     {
-      if (NULL != transmit_handle)
-        {
-          GNUNET_TRANSPORT_notify_transmit_ready_cancel (transmit_handle);
-          transmit_handle = NULL;
-        }
+      GNUNET_TRANSPORT_notify_transmit_ready_cancel (transmit_handle);
+      transmit_handle = NULL;
     }
+  }
   connected--;
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
 #endif
 }
 
@@ -657,46 +647,41 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
-    {
-      GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome);
-      GNUNET_DISK_directory_remove (p->servicehome);
-    }
+  if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
+  {
+    GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME",
+                                           &p->servicehome);
+    GNUNET_DISK_directory_remove (p->servicehome);
+  }
 
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL,
-                                        "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE_ARM
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
 
   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
                                     p,
                                     &notify_receive_new,
-                                    &notify_connect,
-                                    &notify_disconnect);
+                                    &notify_connect, &notify_disconnect);
   GNUNET_assert (p->th != NULL);
 }
 
 
 static void
-try_connect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 #if DEBUG_CONNECTIONS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking peers to connect...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking peers to connect...\n");
 #endif
-  GNUNET_TRANSPORT_try_connect (p2.th,
-                                &p1.id);
-  GNUNET_TRANSPORT_try_connect (p1.th,
-                                &p2.id);
+  GNUNET_TRANSPORT_try_connect (p2.th, &p1.id);
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
   tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                      &try_connect,
-                                      NULL);
+                                      &try_connect, NULL);
 }
 
 
@@ -708,102 +693,100 @@ run (void *cls,
   GNUNET_assert (ok == 1);
   OKPP;
 
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly,
-                                           NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
   measurement_running = GNUNET_NO;
   send_running = GNUNET_NO;
   recv_running = GNUNET_NO;
 
   if (is_tcp)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Testing asymmetric quota compliance (receiver quota constant) for TCP transport plugin\n");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (sender quota constant) for TCP transport plugin\n");
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Testing symmetric quota compliance for TCP transport plugin\n");
-      setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
-      setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (receiver quota constant) for TCP transport plugin\n");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (sender quota constant) for TCP transport plugin\n");
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing symmetric quota compliance for TCP transport plugin\n");
+    setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
+    setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
+  }
   else if (is_http)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (receiver quota constant) for HTTP transport plugin\n");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (sender quota constant) for HTTP transport plugin\n");
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing symmetric quota compliance for HTTP transport plugin\n");
-      setup_peer (&p1, "test_quota_compliance_http_peer1.conf");
-      setup_peer (&p2, "test_quota_compliance_http_peer2.conf");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (receiver quota constant) for HTTP transport plugin\n");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (sender quota constant) for HTTP transport plugin\n");
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing symmetric quota compliance for HTTP transport plugin\n");
+    setup_peer (&p1, "test_quota_compliance_http_peer1.conf");
+    setup_peer (&p2, "test_quota_compliance_http_peer2.conf");
+  }
   else if (is_https)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (receiver quota constant) for HTTPS transport plugin\n");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (sender quota constant) for HTTPS transport plugin\n");
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing symmetric quota compliance for HTTPS transport plugin\n");
-      setup_peer (&p1, "test_quota_compliance_https_peer1.conf");
-      setup_peer (&p2, "test_quota_compliance_https_peer2.conf");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (receiver quota constant) for HTTPS transport plugin\n");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (sender quota constant) for HTTPS transport plugin\n");
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing symmetric quota compliance for HTTPS transport plugin\n");
+    setup_peer (&p1, "test_quota_compliance_https_peer1.conf");
+    setup_peer (&p2, "test_quota_compliance_https_peer2.conf");
+  }
   else if (is_udp)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (receiver quota constant) for UDP transport plugin\n");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (sender quota constant) for UDP transport plugin\n");
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing symmetric quota compliance for UDP transport plugin\n");
-      setup_peer (&p1, "test_quota_compliance_udp_peer1.conf");
-      setup_peer (&p2, "test_quota_compliance_udp_peer2.conf");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (receiver quota constant) for UDP transport plugin\n");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (sender quota constant) for UDP transport plugin\n");
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing symmetric quota compliance for UDP transport plugin\n");
+    setup_peer (&p1, "test_quota_compliance_udp_peer1.conf");
+    setup_peer (&p2, "test_quota_compliance_udp_peer2.conf");
+  }
   else if (is_unix)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (receiver quota constant) for UNIX transport plugin\n");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (sender quota constant) for UNIX transport plugin\n");
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing symmetric quota compliance for UNIX transport plugin\n");
-      setup_peer (&p1, "test_quota_compliance_unix_peer1.conf");
-      setup_peer (&p2, "test_quota_compliance_unix_peer2.conf");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (receiver quota constant) for UNIX transport plugin\n");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (sender quota constant) for UNIX transport plugin\n");
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing symmetric quota compliance for UNIX transport plugin\n");
+    setup_peer (&p1, "test_quota_compliance_unix_peer1.conf");
+    setup_peer (&p2, "test_quota_compliance_unix_peer2.conf");
+  }
   else if (is_tcp_nat)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Testing asymmetric quota compliance (receiver quota constant) for TCP NAT transport plugin\n");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing asymmetric quota compliance (sender quota constant) for TCP NAT transport plugin\n");
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                    "Testing symmetric quota compliance for TCP NAT transport plugin\n");
-      setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
-      setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (receiver quota constant) for TCP NAT transport plugin\n");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing asymmetric quota compliance (sender quota constant) for TCP NAT transport plugin\n");
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Testing symmetric quota compliance for TCP NAT transport plugin\n");
+    setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
+    setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
+  }
   else
     GNUNET_assert (0);
 
-  GNUNET_assert(p1.th != NULL);
-  GNUNET_assert(p2.th != NULL);
+  GNUNET_assert (p1.th != NULL);
+  GNUNET_assert (p2.th != NULL);
   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
   tct = GNUNET_SCHEDULER_add_now (&try_connect, NULL);
@@ -814,96 +797,114 @@ int
 main (int argc, char *argv[])
 {
   int ret = 0;
-  if (strstr(argv[0], "tcp_nat") != NULL)
-    {
-      is_tcp_nat = GNUNET_YES;
-    }
-  else if (strstr(argv[0], "tcp") != NULL)
-    {
-      is_tcp = GNUNET_YES;
-    }
-  else if (strstr(argv[0], "https") != NULL)
-    {
-      is_https = GNUNET_YES;
-    }
-  else if (strstr(argv[0], "http") != NULL)
-    {
-      is_http = GNUNET_YES;
-    }
-  else if (strstr(argv[0], "udp") != NULL)
-    {
-      is_udp = GNUNET_YES;
-    }
-  else if (strstr(argv[0], "unix") != NULL)
-    {
-      is_unix = GNUNET_YES;
-    }
 
-  if (strstr(argv[0], "asymmetric_recv") != NULL)
+  if (strstr (argv[0], "tcp_nat") != NULL)
+  {
+    is_tcp_nat = GNUNET_YES;
+  }
+  else if (strstr (argv[0], "tcp") != NULL)
+  {
+    is_tcp = GNUNET_YES;
+  }
+  else if (strstr (argv[0], "https") != NULL)
+  {
+    is_https = GNUNET_YES;
+  }
+  else if (strstr (argv[0], "http") != NULL)
+  {
+    is_http = GNUNET_YES;
+  }
+  else if (strstr (argv[0], "udp") != NULL)
+  {
+    is_udp = GNUNET_YES;
+  }
+  else if (strstr (argv[0], "unix") != NULL)
+  {
+    is_unix = GNUNET_YES;
+  }
+
+  if (strstr (argv[0], "asymmetric_recv") != NULL)
   {
     is_asymmetric_recv_constant = GNUNET_YES;
   }
   else
     is_asymmetric_recv_constant = GNUNET_NO;
-  if (strstr(argv[0], "asymmetric_send") != NULL)
-    {
-      is_asymmetric_send_constant = GNUNET_YES;
-    }
+  if (strstr (argv[0], "asymmetric_send") != NULL)
+  {
+    is_asymmetric_send_constant = GNUNET_YES;
+  }
   else
     is_asymmetric_send_constant = GNUNET_NO;
-  
-  char * logger;
+
+  char *logger;
+
   if (is_tcp == GNUNET_YES)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_recv_constant");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_send_constant");
-      else
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","symmetric");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "tcp",
+                       "asymmetric_recv_constant");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "tcp",
+                       "asymmetric_send_constant");
+    else
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "tcp",
+                       "symmetric");
+  }
   else if (is_udp == GNUNET_YES)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_recv_constant");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_send_constant");
-      else
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","symmetric");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "udp",
+                       "asymmetric_recv_constant");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "udp",
+                       "asymmetric_send_constant");
+    else
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "udp",
+                       "symmetric");
+  }
   else if (is_unix == GNUNET_YES)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_recv_constant");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_send_constant");
-      else
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","symmetric");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "unix",
+                       "asymmetric_recv_constant");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "unix",
+                       "asymmetric_send_constant");
+    else
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "unix",
+                       "symmetric");
+  }
   else if (is_http == GNUNET_YES)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_recv_constant");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_send_constant");
-      else
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","symmetric");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "http",
+                       "asymmetric_recv_constant");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "http",
+                       "asymmetric_send_constant");
+    else
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "http",
+                       "symmetric");
+  }
   else if (is_https == GNUNET_YES)
-    {
-      if (is_asymmetric_recv_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_recv_constant");
-      else if (is_asymmetric_send_constant == GNUNET_YES)
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_send_constant");
-      else
-        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","symmetric");
-    }
+  {
+    if (is_asymmetric_recv_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "https",
+                       "asymmetric_recv_constant");
+    else if (is_asymmetric_send_constant == GNUNET_YES)
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "https",
+                       "asymmetric_send_constant");
+    else
+      GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "https",
+                       "symmetric");
+  }
   else
-    {
-      GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","noplugin","none");
-    }
+  {
+    GNUNET_asprintf (&logger, "test-quota-compliance-%s-%s", "noplugin",
+                     "none");
+  }
 
-  fprintf(stderr,  "Running `%s'\n", logger);
+  fprintf (stderr, "Running `%s'\n", logger);
   GNUNET_log_setup ("test-quota-compliance",
 #if VERBOSE
                     "DEBUG",
@@ -924,23 +925,22 @@ main (int argc, char *argv[])
   };
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv1) / sizeof (char *)) - 1,
-                      argv1, logger , "nohelp",
-                      options, &run, &ok);
+                      argv1, logger, "nohelp", options, &run, &ok);
   ret = ok;
   stop_arm (&p1);
   stop_arm (&p2);
 
   if (p1.servicehome != NULL)
-    {
-      GNUNET_DISK_directory_remove (p1.servicehome);
-      GNUNET_free(p1.servicehome);
-    }
+  {
+    GNUNET_DISK_directory_remove (p1.servicehome);
+    GNUNET_free (p1.servicehome);
+  }
   if (p2.servicehome != NULL)
-    {
-      GNUNET_DISK_directory_remove (p2.servicehome);
-      GNUNET_free(p2.servicehome);
-    }
-  GNUNET_free(logger);
+  {
+    GNUNET_DISK_directory_remove (p2.servicehome);
+    GNUNET_free (p2.servicehome);
+  }
+  GNUNET_free (logger);
   return ret;
 }
 
diff --git a/src/transport/test_transport_api.c b/src/transport/test_transport_api.c
index 0e3473441..f9ac6a8e5 100644
--- a/src/transport/test_transport_api.c
+++ b/src/transport/test_transport_api.c
@@ -57,17 +57,17 @@
 
 static int ok;
 
-static  GNUNET_SCHEDULER_TaskIdentifier die_task;
+static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
-struct PeerContext * p1;
+struct PeerContext *p1;
 
-struct PeerContext * p2;
+struct PeerContext *p2;
 
-struct GNUNET_TRANSPORT_TransmitHandle * th;
+struct GNUNET_TRANSPORT_TransmitHandle *th;
 
-char * cfg_file_p1;
+char *cfg_file_p1;
 
-char * cfg_file_p2;
+char *cfg_file_p2;
 
 #if VERBOSE
 #define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
@@ -82,33 +82,33 @@ end ()
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
 
   if (die_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(die_task);
+    GNUNET_SCHEDULER_cancel (die_task);
 
   if (th != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
   th = NULL;
 
-  GNUNET_TRANSPORT_TESTING_stop_peer(p1);
-  GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p1);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 }
 
 static void
 end_badly ()
 {
   if (die_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(die_task);
+    GNUNET_SCHEDULER_cancel (die_task);
 
   die_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
 
   if (th != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
   th = NULL;
 
   if (p1 != NULL)
-    GNUNET_TRANSPORT_TESTING_stop_peer(p1);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p1);
   if (p2 != NULL)
-    GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 
   ok = GNUNET_SYSERR;
 }
@@ -121,22 +121,21 @@ notify_receive (void *cls,
                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
                 uint32_t ats_count)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Received message of type %d from peer %s!\n",
-              ntohs(message->type), 
-              GNUNET_i2s (peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received message of type %d from peer %s!\n",
+              ntohs (message->type), GNUNET_i2s (peer));
 
   if ((MTYPE == ntohs (message->type)) &&
       (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size)))
   {
     ok = 0;
-    end();
+    end ();
   }
   else
   {
     GNUNET_break (0);
     ok = 1;
-    end();
+    end ();
   }
 }
 
@@ -150,9 +149,8 @@ notify_ready (void *cls, size_t size, void *buf)
   th = NULL;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting message with %u bytes to peer %s\n", 
-              sizeof (struct GNUNET_MessageHeader),
-              GNUNET_i2s (&p->id));
+              "Transmitting message with %u bytes to peer %s\n",
+              sizeof (struct GNUNET_MessageHeader), GNUNET_i2s (&p->id));
   GNUNET_assert (size >= 256);
 
   if (buf != NULL)
@@ -172,41 +170,37 @@ notify_connect (void *cls,
                 uint32_t ats_count)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n", 
-              GNUNET_i2s (peer), 
-              cls);
+              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
 }
 
 
 static void
-notify_disconnect (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
 }
 
 static void
 sendtask ()
 {
   th = GNUNET_TRANSPORT_notify_transmit_ready (p1->th,
-                                              &p2->id,
-                                              256, 0, TIMEOUT, &notify_ready,
-                                              &p1);
+                                               &p2->id,
+                                               256, 0, TIMEOUT, &notify_ready,
+                                               &p1);
 }
 
 static void
-testing_connect_cb (struct PeerContext * p1, struct PeerContext * p2, void *cls)
+testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
 {
-  char * p1_c = strdup (GNUNET_i2s(&p1->id));
+  char *p1_c = strdup (GNUNET_i2s (&p1->id));
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %s <-> %s\n",
-       p1_c,
-       GNUNET_i2s (&p2->id));
+              p1_c, GNUNET_i2s (&p2->id));
   GNUNET_free (p1_c);
 
   // FIXME: THIS IS REQUIRED! SEEMS TO BE A BUG!
-  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &sendtask, NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &sendtask, NULL);
 }
 
 static void
@@ -214,21 +208,18 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly, NULL);
-
-  p1 = GNUNET_TRANSPORT_TESTING_start_peer(cfg_file_p1,
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      NULL);
-  p2 = GNUNET_TRANSPORT_TESTING_start_peer(cfg_file_p2,
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      NULL);
-
-  GNUNET_TRANSPORT_TESTING_connect_peers(p1, p2, &testing_connect_cb, NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+
+  p1 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p1,
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, NULL);
+  p2 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p2,
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, NULL);
+
+  GNUNET_TRANSPORT_TESTING_connect_peers (p1, p2, &testing_connect_cb, NULL);
 }
 
 static int
@@ -247,12 +238,11 @@ check ()
   };
 
 #if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
+  setTransportOptions ("test_transport_api_data.conf");
 #endif
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-transport-api", "nohelp",
-                      options, &run, &ok);
+                      argv, "test-transport-api", "nohelp", options, &run, &ok);
 
   return ok;
 }
@@ -274,32 +264,32 @@ get_path_from_PATH (char *binary)
 
   p = getenv ("PATH");
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("PATH environment variable is unset.\n"));
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("PATH environment variable is unset.\n"));
+    return NULL;
+  }
   path = GNUNET_strdup (p);     /* because we write on it */
   buf = GNUNET_malloc (strlen (path) + 20);
   pos = path;
 
   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
-    {
-      *end = '\0';
-      sprintf (buf, "%s/%s", pos, binary);
-      if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-        {
-          GNUNET_free (path);
-          return buf;
-        }
-      pos = end + 1;
-    }
-  sprintf (buf, "%s/%s", pos, binary);
-  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    *end = '\0';
+    sprintf (buf, "%s/%s", pos, binary);
+    if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
     {
       GNUNET_free (path);
       return buf;
     }
+    pos = end + 1;
+  }
+  sprintf (buf, "%s/%s", pos, binary);
+  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    GNUNET_free (path);
+    return buf;
+  }
   GNUNET_free (buf);
   GNUNET_free (path);
   return NULL;
@@ -316,16 +306,18 @@ get_path_from_PATH (char *binary)
  *         can be run properly, GNUNET_NO otherwise
  */
 static int
-check_gnunet_nat_binary(char *binary)
+check_gnunet_nat_binary (char *binary)
 {
   struct stat statbuf;
   char *p;
+
 #ifdef MINGW
   SOCKET rawsock;
 #endif
 
 #ifdef MINGW
   char *binaryexe;
+
   GNUNET_asprintf (&binaryexe, "%s.exe", binary);
   p = get_path_from_PATH (binaryexe);
   free (binaryexe);
@@ -333,36 +325,34 @@ check_gnunet_nat_binary(char *binary)
   p = get_path_from_PATH (binary);
 #endif
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not find binary `%s' in PATH!\n"),
-                  binary);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not find binary `%s' in PATH!\n"), binary);
+    return GNUNET_NO;
+  }
   if (0 != STAT (p, &statbuf))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("stat (%s) failed: %s\n"),
-                  p,
-                  STRERROR (errno));
-      GNUNET_free (p);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("stat (%s) failed: %s\n"), p, STRERROR (errno));
+    GNUNET_free (p);
+    return GNUNET_SYSERR;
+  }
   GNUNET_free (p);
 #ifndef MINGW
-  if ( (0 != (statbuf.st_mode & S_ISUID)) &&
-       (statbuf.st_uid == 0) )
+  if ((0 != (statbuf.st_mode & S_ISUID)) && (statbuf.st_uid == 0))
     return GNUNET_YES;
   return GNUNET_NO;
 #else
   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (INVALID_SOCKET == rawsock)
-    {
-      DWORD err = GetLastError ();
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n", err);
-      return GNUNET_NO; /* not running as administrator */
-    }
+  {
+    DWORD err = GetLastError ();
+
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n",
+                err);
+    return GNUNET_NO;           /* not running as administrator */
+  }
   closesocket (rawsock);
   return GNUNET_YES;
 #endif
@@ -381,13 +371,13 @@ main (int argc, char *argv[])
 #endif
                     NULL);
 
-  char * pch = strdup(argv[0]);
-  char * backup = pch;
-  char * filename = NULL;
+  char *pch = strdup (argv[0]);
+  char *backup = pch;
+  char *filename = NULL;
   char *dotexe;
 
   /* get executable filename */
-  pch = strtok (pch,"/");
+  pch = strtok (pch, "/");
   while (pch != NULL)
   {
     pch = strtok (NULL, "/");
@@ -395,35 +385,35 @@ main (int argc, char *argv[])
       filename = pch;
   }
   /* remove "lt-" */
-  filename = strstr(filename, "tes");
+  filename = strstr (filename, "tes");
   if (NULL != (dotexe = strstr (filename, ".exe")))
     dotexe[0] = '\0';
 
   /* create cfg filename */
-  GNUNET_asprintf(&cfg_file_p1, "%s_peer1.conf",filename);
-  GNUNET_asprintf(&cfg_file_p2, "%s_peer2.conf", filename);
+  GNUNET_asprintf (&cfg_file_p1, "%s_peer1.conf", filename);
+  GNUNET_asprintf (&cfg_file_p2, "%s_peer2.conf", filename);
   GNUNET_free (backup);
 
-  if (strstr(argv[0], "tcp_nat") != NULL)
+  if (strstr (argv[0], "tcp_nat") != NULL)
+  {
+    if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
     {
-      if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                      "gnunet-nat-server");
-          return 0;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "`%s' not properly installed, cannot run NAT test!\n",
+                  "gnunet-nat-server");
+      return 0;
     }
-  else if (strstr(argv[0], "udp_nat") != NULL)
+  }
+  else if (strstr (argv[0], "udp_nat") != NULL)
+  {
+    if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
     {
-      if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                      "gnunet-nat-server");
-          return 0;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "`%s' not properly installed, cannot run NAT test!\n",
+                  "gnunet-nat-server");
+      return 0;
     }
+  }
 
   ret = check ();
 
diff --git a/src/transport/test_transport_api_disconnect.c b/src/transport/test_transport_api_disconnect.c
index 35cda3d04..08f57b670 100644
--- a/src/transport/test_transport_api_disconnect.c
+++ b/src/transport/test_transport_api_disconnect.c
@@ -67,11 +67,11 @@ static int peers_connected = 0;
 static int counter;
 static int msgs_recv;
 
-static  GNUNET_SCHEDULER_TaskIdentifier die_task;
+static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
-static  GNUNET_SCHEDULER_TaskIdentifier tct;
+static GNUNET_SCHEDULER_TaskIdentifier tct;
 
-struct GNUNET_TRANSPORT_TransmitHandle * th;
+struct GNUNET_TRANSPORT_TransmitHandle *th;
 
 #if VERBOSE
 #define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
@@ -80,18 +80,16 @@ struct GNUNET_TRANSPORT_TransmitHandle * th;
 #endif
 
 
-static void
-peers_connect ();
+static void peers_connect ();
 
 static void
 end ()
 {
   if (GNUNET_SCHEDULER_NO_TASK != die_task)
     GNUNET_SCHEDULER_cancel (die_task);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting from transports!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
   if (th != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
   th = NULL;
 
   if (p1.th != NULL)
@@ -100,8 +98,8 @@ end ()
   if (p2.th != NULL)
     GNUNET_TRANSPORT_disconnect (p2.th);
   die_task = GNUNET_SCHEDULER_NO_TASK;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Transports disconnected, returning success!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transports disconnected, returning success!\n");
   ok = 0;
 }
 
@@ -110,13 +108,13 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      GNUNET_OS_process_wait (p->arm_proc);
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    GNUNET_OS_process_wait (p->arm_proc);
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -125,16 +123,15 @@ stop_arm (struct PeerContext *p)
 
 
 static void
-exchange_hello_last (void *cls,
-                     const struct GNUNET_MessageHeader *message)
+exchange_hello_last (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
   GNUNET_assert (message != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d with peer (%s)!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d with peer (%s)!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
@@ -143,8 +140,7 @@ exchange_hello_last (void *cls,
 
 
 static void
-exchange_hello (void *cls,
-                const struct GNUNET_MessageHeader *message)
+exchange_hello (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
@@ -153,9 +149,9 @@ exchange_hello (void *cls,
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d from peer %s!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d from peer %s!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 }
 
@@ -167,23 +163,23 @@ end_badly ()
   GNUNET_break (0);
 
   if (th != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
-      th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
+    th = NULL;
+  }
   else
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
-      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
+    GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
+  }
 
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
   if (GNUNET_SCHEDULER_NO_TASK != tct)
-    {
-      GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+  }
   ok = 1;
 }
 
@@ -196,20 +192,17 @@ notify_receive (void *cls,
                 uint32_t ats_count)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received message of type %d from peer %s!\n",
-              ntohs(message->type), 
-              GNUNET_i2s (peer));
+              "Received message of type %d from peer %s!\n",
+              ntohs (message->type), GNUNET_i2s (peer));
   OKPP;
   GNUNET_assert (MTYPE == ntohs (message->type));
-  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
-                 ntohs (message->size));
+  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size));
 
   msgs_recv++;
 }
 
 static void
-peers_disconnect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc);
+peers_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 static size_t
 notify_ready (void *cls, size_t size, void *buf)
@@ -220,9 +213,8 @@ notify_ready (void *cls, size_t size, void *buf)
   th = NULL;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting message with %u bytes to peer %s\n", 
-              sizeof (struct GNUNET_MessageHeader),
-              GNUNET_i2s (&p->id));
+              "Transmitting message with %u bytes to peer %s\n",
+              sizeof (struct GNUNET_MessageHeader), GNUNET_i2s (&p->id));
   GNUNET_assert (size >= 256);
   OKPP;
   if (buf != NULL)
@@ -245,94 +237,83 @@ notify_connect (void *cls,
                 uint32_t ats_count)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n", 
-              GNUNET_i2s (peer), 
-              cls);
+              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
   peers_connected++;
   if (cls == &p1)
-    {
-      GNUNET_assert (ok >= 2);
-      OKPP;
-      OKPP;
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      if (GNUNET_SCHEDULER_NO_TASK != tct)
-        GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT,
-                                               &end_badly, NULL);
-      th = GNUNET_TRANSPORT_notify_transmit_ready (p1.th,
-                                              &p2.id,
-                                              256, 0, TIMEOUT, &notify_ready,
-                                              &p1);
-    }
+  {
+    GNUNET_assert (ok >= 2);
+    OKPP;
+    OKPP;
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    if (GNUNET_SCHEDULER_NO_TASK != tct)
+      GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT,
+                                             &end_badly, NULL);
+    th = GNUNET_TRANSPORT_notify_transmit_ready (p1.th,
+                                                 &p2.id,
+                                                 256, 0, TIMEOUT, &notify_ready,
+                                                 &p1);
+  }
 }
 
 
 static void
-notify_disconnect (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
   peers_connected--;
 }
 
 
 static void
-setup_peer (struct PeerContext *p, 
-            const char *cfgname)
+setup_peer (struct PeerContext *p, const char *cfgname)
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
 
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome);
+  if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME",
+                                           &p->servicehome);
   if (NULL != p->servicehome)
-    GNUNET_DISK_directory_remove (p->servicehome);    
+    GNUNET_DISK_directory_remove (p->servicehome);
 
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE_ARM
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
 
 }
 
 
 static void
-try_connect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking peers to connect...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking peers to connect...\n");
   /* FIXME: 'pX.id' may still be all-zeros here... */
-  GNUNET_TRANSPORT_try_connect (p2.th,
-                                &p1.id);
-  GNUNET_TRANSPORT_try_connect (p1.th,
-                                &p2.id);
+  GNUNET_TRANSPORT_try_connect (p2.th, &p1.id);
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
   tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                      &try_connect,
-                                      NULL);
+                                      &try_connect, NULL);
 }
 
 
 static void
-peers_disconnect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+peers_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
 
   //while (peers_connected > 0);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting from Transport \n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Transport \n");
 
   GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
   GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
@@ -343,10 +324,10 @@ peers_disconnect (void *cls,
   GNUNET_TRANSPORT_disconnect (p2.th);
   p2.th = NULL;
 
-  while (peers_connected > 0);
+  while (peers_connected > 0) ;
 
   if (counter < ITERATIONS)
-    peers_connect();
+    peers_connect ();
   else
     end ();
 }
@@ -354,8 +335,9 @@ peers_disconnect (void *cls,
 static void
 peers_connect ()
 {
-  counter ++;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration %i of %i\n", counter, ITERATIONS);
+  counter++;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration %i of %i\n", counter,
+              ITERATIONS);
 
   GNUNET_assert (p1.th == NULL);
   p1.th = GNUNET_TRANSPORT_connect (p1.cfg,
@@ -369,8 +351,8 @@ peers_connect ()
                                     &notify_receive,
                                     &notify_connect, &notify_disconnect);
 
-  GNUNET_assert(p1.th != NULL);
-  GNUNET_assert(p2.th != NULL);
+  GNUNET_assert (p1.th != NULL);
+  GNUNET_assert (p2.th != NULL);
 
   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
@@ -384,8 +366,7 @@ run (void *cls,
 {
   GNUNET_assert (ok == 1);
   OKPP;
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly, NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 
   setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
   setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
@@ -409,25 +390,24 @@ check ()
   };
 
 #if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
+  setTransportOptions ("test_transport_api_data.conf");
 #endif
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-transport-api", "nohelp",
-                      options, &run, &ok);
+                      argv, "test-transport-api", "nohelp", options, &run, &ok);
   stop_arm (&p1);
   stop_arm (&p2);
 
   if (p1.servicehome != NULL)
-    {
+  {
     GNUNET_DISK_directory_remove (p1.servicehome);
-    GNUNET_free(p1.servicehome);
-    }
+    GNUNET_free (p1.servicehome);
+  }
   if (p2.servicehome != NULL)
-    {
-      GNUNET_DISK_directory_remove (p2.servicehome);
-      GNUNET_free(p2.servicehome);
-    }
+  {
+    GNUNET_DISK_directory_remove (p2.servicehome);
+    GNUNET_free (p2.servicehome);
+  }
   return ok;
 }
 
diff --git a/src/transport/test_transport_api_multiaddress.c b/src/transport/test_transport_api_multiaddress.c
index b2ac507d2..63ef28862 100644
--- a/src/transport/test_transport_api_multiaddress.c
+++ b/src/transport/test_transport_api_multiaddress.c
@@ -63,9 +63,9 @@ static int ok;
 
 static int is_tcp;
 
-static  GNUNET_SCHEDULER_TaskIdentifier die_task;
+static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
-static  GNUNET_SCHEDULER_TaskIdentifier tct;
+static GNUNET_SCHEDULER_TaskIdentifier tct;
 
 
 #if VERBOSE
@@ -81,13 +81,13 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      GNUNET_OS_process_wait (p->arm_proc);
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    GNUNET_OS_process_wait (p->arm_proc);
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -96,16 +96,15 @@ stop_arm (struct PeerContext *p)
 
 
 static void
-exchange_hello_last (void *cls,
-                     const struct GNUNET_MessageHeader *message)
+exchange_hello_last (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
   GNUNET_assert (message != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d with peer (%s)!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d with peer (%s)!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
@@ -114,8 +113,7 @@ exchange_hello_last (void *cls,
 
 
 static void
-exchange_hello (void *cls,
-                const struct GNUNET_MessageHeader *message)
+exchange_hello (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
@@ -124,9 +122,9 @@ exchange_hello (void *cls,
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d from peer %s!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d from peer %s!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 }
 
@@ -142,10 +140,10 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
   if (GNUNET_SCHEDULER_NO_TASK != tct)
-    {
-      GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+  }
   ok = 1;
 }
 
@@ -159,10 +157,10 @@ end_normally (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
   if (GNUNET_SCHEDULER_NO_TASK != tct)
-    {
-      GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+  }
   ok = 0;
 }
 
@@ -173,87 +171,76 @@ notify_connect (void *cls,
                 uint32_t ats_count)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n", 
-              GNUNET_i2s (peer), 
-              cls);
+              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
   if (cls == &p1)
-    {
-      GNUNET_assert (ok >= 2);
-      OKPP;
-      OKPP;
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      if (GNUNET_SCHEDULER_NO_TASK != tct)
-        GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT,
-                                               &end_normally, NULL);
-    }
+  {
+    GNUNET_assert (ok >= 2);
+    OKPP;
+    OKPP;
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    if (GNUNET_SCHEDULER_NO_TASK != tct)
+      GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT,
+                                             &end_normally, NULL);
+  }
 }
 
 
 static void
-notify_disconnect (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
-   if ( (ok != 60) &&
-         (GNUNET_SCHEDULER_NO_TASK != die_task) )
-     {
-       GNUNET_SCHEDULER_cancel (die_task);
-       die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-     }
+  if ((ok != 60) && (GNUNET_SCHEDULER_NO_TASK != die_task))
+  {
+    GNUNET_SCHEDULER_cancel (die_task);
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
 }
 
 
 static void
-setup_peer (struct PeerContext *p, 
-            const char *cfgname)
+setup_peer (struct PeerContext *p, const char *cfgname)
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
 
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
-    {
-      GNUNET_assert (GNUNET_OK == 
-                     GNUNET_CONFIGURATION_get_value_string (p->cfg, 
-                                                            "PATHS", "SERVICEHOME", 
-                                                            &p->servicehome));
-      GNUNET_DISK_directory_remove (p->servicehome);
-    }
+  if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
+  {
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONFIGURATION_get_value_string (p->cfg,
+                                                          "PATHS",
+                                                          "SERVICEHOME",
+                                                          &p->servicehome));
+    GNUNET_DISK_directory_remove (p->servicehome);
+  }
 
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE_ARM
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   p->th = GNUNET_TRANSPORT_connect (p->cfg,
                                     NULL, p,
-                                    NULL,
-                                    &notify_connect, &notify_disconnect);
+                                    NULL, &notify_connect, &notify_disconnect);
   GNUNET_assert (p->th != NULL);
 }
 
 
 static void
-try_connect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking peers to connect...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking peers to connect...\n");
   /* FIXME: 'pX.id' may still be all-zeros here... */
-  GNUNET_TRANSPORT_try_connect (p2.th,
-                                &p1.id);
-  GNUNET_TRANSPORT_try_connect (p1.th,
-                                &p2.id);
+  GNUNET_TRANSPORT_try_connect (p2.th, &p1.id);
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
   tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                      &try_connect,
-                                      NULL);
+                                      &try_connect, NULL);
 }
 
 
@@ -264,15 +251,14 @@ run (void *cls,
 {
   GNUNET_assert (ok == 1);
   OKPP;
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly, NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
   if (is_tcp)
-    {
-      setup_peer (&p1, "test_transport_api_multiaddress_tcp_peer1.conf");
-      setup_peer (&p2, "test_transport_api_multiaddress_tcp_peer2.conf");
-    }
-  GNUNET_assert(p1.th != NULL);
-  GNUNET_assert(p2.th != NULL);
+  {
+    setup_peer (&p1, "test_transport_api_multiaddress_tcp_peer1.conf");
+    setup_peer (&p2, "test_transport_api_multiaddress_tcp_peer2.conf");
+  }
+  GNUNET_assert (p1.th != NULL);
+  GNUNET_assert (p2.th != NULL);
 
   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
@@ -295,25 +281,24 @@ check ()
   };
 
 #if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
+  setTransportOptions ("test_transport_api_data.conf");
 #endif
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-transport-api", "nohelp",
-                      options, &run, &ok);
+                      argv, "test-transport-api", "nohelp", options, &run, &ok);
   stop_arm (&p1);
   stop_arm (&p2);
 
   if (p1.servicehome != NULL)
-    {
-      GNUNET_DISK_directory_remove (p1.servicehome);
-      GNUNET_free(p1.servicehome);
-    }
+  {
+    GNUNET_DISK_directory_remove (p1.servicehome);
+    GNUNET_free (p1.servicehome);
+  }
   if (p2.servicehome != NULL)
-    {
-      GNUNET_DISK_directory_remove (p2.servicehome);
-      GNUNET_free(p2.servicehome);
-    }
+  {
+    GNUNET_DISK_directory_remove (p2.servicehome);
+    GNUNET_free (p2.servicehome);
+  }
   return ok;
 }
 
@@ -331,10 +316,10 @@ main (int argc, char *argv[])
 #endif
                     NULL);
 
-  if (strstr(argv[0], "tcp") != NULL)
-    {
-      is_tcp = GNUNET_YES;
-    }
+  if (strstr (argv[0], "tcp") != NULL)
+  {
+    is_tcp = GNUNET_YES;
+  }
 
   ret = check ();
 
diff --git a/src/transport/test_transport_api_reliability.c b/src/transport/test_transport_api_reliability.c
index 37395ad0f..60191394d 100644
--- a/src/transport/test_transport_api_reliability.c
+++ b/src/transport/test_transport_api_reliability.c
@@ -51,17 +51,17 @@
 
 static int ok;
 
-static  GNUNET_SCHEDULER_TaskIdentifier die_task;
+static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
-struct PeerContext * p1;
+struct PeerContext *p1;
 
-struct PeerContext * p2;
+struct PeerContext *p2;
 
-struct GNUNET_TRANSPORT_TransmitHandle * th;
+struct GNUNET_TRANSPORT_TransmitHandle *th;
 
-char * cfg_file_p1;
+char *cfg_file_p1;
 
-char * cfg_file_p2;
+char *cfg_file_p2;
 
 /*
  * Testcase specific declarations
@@ -108,27 +108,27 @@ static void
 end ()
 {
   unsigned long long delta;
+
   //char *value_name;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
 
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
   fprintf (stderr,
-           "\nThroughput was %llu kb/s\n",
-           total_bytes * 1000 / 1024 / delta);
+           "\nThroughput was %llu kb/s\n", total_bytes * 1000 / 1024 / delta);
   //GNUNET_asprintf(&value_name, "reliable_%s", test_name);
   //GAUGER ("TRANSPORT", value_name, (int)(total_bytes * 1000 / 1024 /delta), "kb/s");
   //GNUNET_free(value_name);
 
   if (die_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(die_task);
+    GNUNET_SCHEDULER_cancel (die_task);
 
   if (th != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
   th = NULL;
 
-  GNUNET_TRANSPORT_TESTING_stop_peer(p1);
-  GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p1);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 }
 
 static void
@@ -138,13 +138,13 @@ end_badly ()
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
 
   if (th != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
   th = NULL;
 
   if (p1 != NULL)
-    GNUNET_TRANSPORT_TESTING_stop_peer(p1);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p1);
   if (p2 != NULL)
-    GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 
   ok = GNUNET_SYSERR;
 }
@@ -172,75 +172,66 @@ notify_receive (void *cls,
   char cbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
   const struct TestMessage *hdr;
 
-  hdr = (const struct TestMessage*) message;
+  hdr = (const struct TestMessage *) message;
   s = get_size (n);
   if (MTYPE != ntohs (message->type))
     return;
   msg_recv_expected = n;
-  msg_recv = ntohl(hdr->num);
+  msg_recv = ntohl (hdr->num);
   if (ntohs (message->size) != (s))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, s, ntohs (message->size), ntohl (hdr->num));
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
   if (ntohl (hdr->num) != n)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, s, ntohs (message->size), ntohl (hdr->num));
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
   memset (cbuf, n, s - sizeof (struct TestMessage));
-  if (0 != memcmp (cbuf,
-                   &hdr[1],
-                   s - sizeof (struct TestMessage)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u with bits %u, but body did not match\n",
-                  n, (unsigned char) n);
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  if (0 != memcmp (cbuf, &hdr[1], s - sizeof (struct TestMessage)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u with bits %u, but body did not match\n",
+                n, (unsigned char) n);
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
 #if VERBOSE
-  if (ntohl(hdr->num) % 5000 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Got message %u of size %u\n",
-                  ntohl (hdr->num),
-                  ntohs (message->size));
-    }
+  if (ntohl (hdr->num) % 5000 == 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got message %u of size %u\n",
+                ntohl (hdr->num), ntohs (message->size));
+  }
 #endif
   n++;
-  if (0 == (n % (TOTAL_MSGS/100)))
-    {
-      fprintf (stderr, ".");
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly,
-                                               NULL);
-    }
+  if (0 == (n % (TOTAL_MSGS / 100)))
+  {
+    fprintf (stderr, ".");
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+  }
   if (n == TOTAL_MSGS)
   {
     ok = 0;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"All messages received\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All messages received\n");
     end ();
   }
 }
@@ -256,11 +247,11 @@ notify_ready (void *cls, size_t size, void *buf)
   unsigned int ret;
 
   if (buf == NULL)
-    {
-      GNUNET_break (0);
-      ok = 42;
-      return 0;
-    }
+  {
+    GNUNET_break (0);
+    ok = 42;
+    return 0;
+  }
   th = NULL;
   ret = 0;
   s = get_size (n);
@@ -268,50 +259,46 @@ notify_ready (void *cls, size_t size, void *buf)
   GNUNET_assert (buf != NULL);
   cbuf = buf;
   do
-    {
-      hdr.header.size = htons (s);
-      hdr.header.type = htons (MTYPE);
-      hdr.num = htonl (n);
-      msg_sent = n;
-      memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
-      ret += sizeof (struct TestMessage);
-      memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
-      ret += s - sizeof (struct TestMessage);
+  {
+    hdr.header.size = htons (s);
+    hdr.header.type = htons (MTYPE);
+    hdr.num = htonl (n);
+    msg_sent = n;
+    memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+    ret += sizeof (struct TestMessage);
+    memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
+    ret += s - sizeof (struct TestMessage);
 #if VERBOSE
-      if (n % 5000 == 0)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Sending message %u of size %u\n",
-                      n,
-                      s);
-        }
-#endif
-      n++;
-      s = get_size (n);
-      if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
-        break; /* sometimes pack buffer full, sometimes not */
+    if (n % 5000 == 0)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending message %u of size %u\n", n, s);
     }
+#endif
+    n++;
+    s = get_size (n);
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+      break;                    /* sometimes pack buffer full, sometimes not */
+  }
   while (size - ret >= s);
   if (n < TOTAL_MSGS)
   {
     if (th == NULL)
       th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th,
-                                            &p1->id,
-                                            s, 0, TIMEOUT,
-                                            &notify_ready,
-                                            NULL);
+                                                   &p1->id,
+                                                   s, 0, TIMEOUT,
+                                                   &notify_ready, NULL);
     msg_scheduled = n;
   }
   if (n % 5000 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Returning total message block of size %u\n",
-                  ret);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Returning total message block of size %u\n", ret);
+  }
   total_bytes += ret;
   if (n == TOTAL_MSGS)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"All messages sent\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All messages sent\n");
   }
   return ret;
 }
@@ -325,34 +312,34 @@ notify_connect (void *cls,
 {
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n",
-              GNUNET_i2s (peer),
-              cls);
+              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
 
   if (cls == p1)
-    {
-      GNUNET_TRANSPORT_set_quota (p1->th,
-                                  &p2->id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-    }
-  else  if (cls == p2)
-    {
-      GNUNET_TRANSPORT_set_quota (p2->th,
-                                  &p1->id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-    }
+  {
+    GNUNET_TRANSPORT_set_quota (p1->th,
+                                &p2->id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+  }
+  else if (cls == p2)
+  {
+    GNUNET_TRANSPORT_set_quota (p2->th,
+                                &p1->id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+  }
 }
 
 
 static void
-notify_disconnect (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
 }
 
 static void
@@ -360,23 +347,22 @@ sendtask ()
 {
   start_time = GNUNET_TIME_absolute_get ();
   th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th,
-                                          &p1->id,
-                                          get_size (0), 0, TIMEOUT,
-                                          &notify_ready,
-                                          NULL);
+                                               &p1->id,
+                                               get_size (0), 0, TIMEOUT,
+                                               &notify_ready, NULL);
 }
 
 static void
-testing_connect_cb (struct PeerContext * p1, struct PeerContext * p2, void *cls)
+testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
 {
-  char * p1_c = strdup (GNUNET_i2s(&p1->id));
+  char *p1_c = strdup (GNUNET_i2s (&p1->id));
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %s <-> %s\n",
-       p1_c,
-       GNUNET_i2s (&p2->id));
+              p1_c, GNUNET_i2s (&p2->id));
   GNUNET_free (p1_c);
 
   // FIXME: THIS IS REQUIRED! SEEMS TO BE A BUG!
-  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &sendtask, NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &sendtask, NULL);
 }
 
 static void
@@ -384,21 +370,18 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly, NULL);
-
-  p1 = GNUNET_TRANSPORT_TESTING_start_peer(cfg_file_p1,
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      NULL);
-  p2 = GNUNET_TRANSPORT_TESTING_start_peer(cfg_file_p2,
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      NULL);
-
-  GNUNET_TRANSPORT_TESTING_connect_peers(p1, p2, &testing_connect_cb, NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+
+  p1 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p1,
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, NULL);
+  p2 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p2,
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, NULL);
+
+  GNUNET_TRANSPORT_TESTING_connect_peers (p1, p2, &testing_connect_cb, NULL);
 }
 
 static int
@@ -417,12 +400,11 @@ check ()
   };
 
 #if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
+  setTransportOptions ("test_transport_api_data.conf");
 #endif
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-transport-api", "nohelp",
-                      options, &run, &ok);
+                      argv, "test-transport-api", "nohelp", options, &run, &ok);
 
   return ok;
 }
@@ -444,32 +426,32 @@ get_path_from_PATH (char *binary)
 
   p = getenv ("PATH");
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("PATH environment variable is unset.\n"));
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("PATH environment variable is unset.\n"));
+    return NULL;
+  }
   path = GNUNET_strdup (p);     /* because we write on it */
   buf = GNUNET_malloc (strlen (path) + 20);
   pos = path;
 
   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
-    {
-      *end = '\0';
-      sprintf (buf, "%s/%s", pos, binary);
-      if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-        {
-          GNUNET_free (path);
-          return buf;
-        }
-      pos = end + 1;
-    }
-  sprintf (buf, "%s/%s", pos, binary);
-  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    *end = '\0';
+    sprintf (buf, "%s/%s", pos, binary);
+    if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
     {
       GNUNET_free (path);
       return buf;
     }
+    pos = end + 1;
+  }
+  sprintf (buf, "%s/%s", pos, binary);
+  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    GNUNET_free (path);
+    return buf;
+  }
   GNUNET_free (buf);
   GNUNET_free (path);
   return NULL;
@@ -486,16 +468,18 @@ get_path_from_PATH (char *binary)
  *         can be run properly, GNUNET_NO otherwise
  */
 static int
-check_gnunet_nat_binary(char *binary)
+check_gnunet_nat_binary (char *binary)
 {
   struct stat statbuf;
   char *p;
+
 #ifdef MINGW
   SOCKET rawsock;
 #endif
 
 #ifdef MINGW
   char *binaryexe;
+
   GNUNET_asprintf (&binaryexe, "%s.exe", binary);
   p = get_path_from_PATH (binaryexe);
   free (binaryexe);
@@ -503,36 +487,34 @@ check_gnunet_nat_binary(char *binary)
   p = get_path_from_PATH (binary);
 #endif
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not find binary `%s' in PATH!\n"),
-                  binary);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not find binary `%s' in PATH!\n"), binary);
+    return GNUNET_NO;
+  }
   if (0 != STAT (p, &statbuf))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("stat (%s) failed: %s\n"),
-                  p,
-                  STRERROR (errno));
-      GNUNET_free (p);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("stat (%s) failed: %s\n"), p, STRERROR (errno));
+    GNUNET_free (p);
+    return GNUNET_SYSERR;
+  }
   GNUNET_free (p);
 #ifndef MINGW
-  if ( (0 != (statbuf.st_mode & S_ISUID)) &&
-       (statbuf.st_uid == 0) )
+  if ((0 != (statbuf.st_mode & S_ISUID)) && (statbuf.st_uid == 0))
     return GNUNET_YES;
   return GNUNET_NO;
 #else
   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (INVALID_SOCKET == rawsock)
-    {
-      DWORD err = GetLastError ();
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n", err);
-      return GNUNET_NO; /* not running as administrator */
-    }
+  {
+    DWORD err = GetLastError ();
+
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n",
+                err);
+    return GNUNET_NO;           /* not running as administrator */
+  }
   closesocket (rawsock);
   return GNUNET_YES;
 #endif
@@ -551,13 +533,13 @@ main (int argc, char *argv[])
 #endif
                     NULL);
 
-  char * pch = strdup(argv[0]);
-  char * backup = pch;
-  char * filename = NULL;
+  char *pch = strdup (argv[0]);
+  char *backup = pch;
+  char *filename = NULL;
   char *dotexe;
 
   /* get executable filename */
-  pch = strtok (pch,"/");
+  pch = strtok (pch, "/");
   while (pch != NULL)
   {
     pch = strtok (NULL, "/");
@@ -565,35 +547,35 @@ main (int argc, char *argv[])
       filename = pch;
   }
   /* remove "lt-" */
-  filename = strstr(filename, "tes");
+  filename = strstr (filename, "tes");
   if (NULL != (dotexe = strstr (filename, ".exe")))
     dotexe[0] = '\0';
 
   /* create cfg filename */
-  GNUNET_asprintf(&cfg_file_p1, "%s_peer1.conf",filename);
-  GNUNET_asprintf(&cfg_file_p2, "%s_peer2.conf", filename);
+  GNUNET_asprintf (&cfg_file_p1, "%s_peer1.conf", filename);
+  GNUNET_asprintf (&cfg_file_p2, "%s_peer2.conf", filename);
   GNUNET_free (backup);
 
-  if (strstr(argv[0], "tcp_nat") != NULL)
+  if (strstr (argv[0], "tcp_nat") != NULL)
+  {
+    if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
     {
-      if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                      "gnunet-nat-server");
-          return 0;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "`%s' not properly installed, cannot run NAT test!\n",
+                  "gnunet-nat-server");
+      return 0;
     }
-  else if (strstr(argv[0], "udp_nat") != NULL)
+  }
+  else if (strstr (argv[0], "udp_nat") != NULL)
+  {
+    if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
     {
-      if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                      "gnunet-nat-server");
-          return 0;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "`%s' not properly installed, cannot run NAT test!\n",
+                  "gnunet-nat-server");
+      return 0;
     }
+  }
 
   ret = check ();
 
diff --git a/src/transport/test_transport_api_unreliability.c b/src/transport/test_transport_api_unreliability.c
index e7cb00274..88df23eb4 100644
--- a/src/transport/test_transport_api_unreliability.c
+++ b/src/transport/test_transport_api_unreliability.c
@@ -50,7 +50,7 @@
  * 'MAX_PENDING' in 'gnunet-service-transport.c', otherwise
  * messages may be dropped even for a reliable transport.
  */
-#define TOTAL_MSGS (1024 * 3) /* Total messages should be divisible by 8, so we can make a nice bitmap */
+#define TOTAL_MSGS (1024 * 3)   /* Total messages should be divisible by 8, so we can make a nice bitmap */
 
 /**
  * How long until we give up on transmitting the message?
@@ -91,7 +91,7 @@ static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
 static GNUNET_SCHEDULER_TaskIdentifier tct;
 
-struct GNUNET_TRANSPORT_TransmitHandle * th_p2;
+struct GNUNET_TRANSPORT_TransmitHandle *th_p2;
 
 static char *key_file_p1;
 static char *cert_file_p1;
@@ -123,11 +123,13 @@ set_bit (unsigned int bitIdx)
 {
   size_t arraySlot;
   unsigned int targetBit;
-  if (bitIdx >= sizeof(bitmap) * 8)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "tried to set bit %d of %d(!?!?)\n", bitIdx, sizeof(bitmap) * 8);
-      return;
-    }
+
+  if (bitIdx >= sizeof (bitmap) * 8)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "tried to set bit %d of %d(!?!?)\n",
+                bitIdx, sizeof (bitmap) * 8);
+    return;
+  }
   arraySlot = bitIdx / 8;
   targetBit = (1L << (bitIdx % 8));
   bitmap[arraySlot] |= targetBit;
@@ -144,10 +146,11 @@ int
 get_bit (const char *map, unsigned int bit)
 {
   if (bit >= TOTAL_MSGS)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "get bit %d of %d(!?!?)\n", bit, sizeof(bitmap) * 8);
-      return 0;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "get bit %d of %d(!?!?)\n", bit,
+                sizeof (bitmap) * 8);
+    return 0;
+  }
   return ((map)[bit >> 3] & (1 << (bit & 7))) > 0;
 }
 
@@ -161,13 +164,13 @@ end ()
 
   result = 0;
   for (i = 0; i < TOTAL_MSGS; i++)
+  {
+    if (get_bit (bitmap, i) == 0)
     {
-      if (get_bit(bitmap, i) == 0)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Did not receive message %d\n", i);
-          result = -1;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Did not receive message %d\n", i);
+      result = -1;
     }
+  }
 
   if (GNUNET_SCHEDULER_NO_TASK != die_task)
     GNUNET_SCHEDULER_cancel (die_task);
@@ -176,22 +179,22 @@ end ()
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
 #endif
   if (th_p2 != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th_p2);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
   th_p2 = NULL;
 
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transports disconnected, returning success!\n");
+              "Transports disconnected, returning success!\n");
 #endif
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
-  GNUNET_asprintf(&value_name, "unreliable_%s", test_name);
-  GAUGER ("TRANSPORT", value_name, (int)(total_bytes * 1000 / 1024 /delta), "kb/s");
-  GNUNET_free(value_name);
+  GNUNET_asprintf (&value_name, "unreliable_%s", test_name);
+  GAUGER ("TRANSPORT", value_name, (int) (total_bytes * 1000 / 1024 / delta),
+          "kb/s");
+  GNUNET_free (value_name);
   fprintf (stderr,
-           "\nThroughput was %llu kb/s\n",
-           total_bytes * 1000 / 1024 / delta);
+           "\nThroughput was %llu kb/s\n", total_bytes * 1000 / 1024 / delta);
   ok = result;
 
 }
@@ -203,22 +206,23 @@ end_unreliably ()
   int i;
   int num_failed;
   char *value_name;
+
   num_failed = 0;
   for (i = 0; i < TOTAL_MSGS; i++)
+  {
+    if (get_bit (bitmap, i) == 0)
     {
-      if (get_bit(bitmap, i) == 0)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Did not receive message %d\n", i);
-          num_failed++;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Did not receive message %d\n", i);
+      num_failed++;
     }
+  }
 
   die_task = GNUNET_SCHEDULER_NO_TASK;
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
 #endif
   if (th_p2 != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th_p2);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
 
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
@@ -228,15 +232,16 @@ end_unreliably ()
 #endif
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
   fprintf (stderr,
-           "\nThroughput was %llu kb/s\n",
-           total_bytes * 1000 / 1024 / delta);
-  GNUNET_asprintf(&value_name, "unreliable_%s", test_name);
-  GAUGER ("TRANSPORT", value_name, (int)(total_bytes * 1000 / 1024 /delta), "kb/s");
-  GNUNET_free(value_name);
-  GNUNET_asprintf(&value_name, "unreliable_failed_%s", test_name);
-  GAUGER ("TRANSPORT", value_name, (int)num_failed, "msgs");
-  GNUNET_free(value_name);
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Had %d failed messages!\n", num_failed);
+           "\nThroughput was %llu kb/s\n", total_bytes * 1000 / 1024 / delta);
+  GNUNET_asprintf (&value_name, "unreliable_%s", test_name);
+  GAUGER ("TRANSPORT", value_name, (int) (total_bytes * 1000 / 1024 / delta),
+          "kb/s");
+  GNUNET_free (value_name);
+  GNUNET_asprintf (&value_name, "unreliable_failed_%s", test_name);
+  GAUGER ("TRANSPORT", value_name, (int) num_failed, "msgs");
+  GNUNET_free (value_name);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Had %d failed messages!\n",
+              num_failed);
   ok = 0;
 
 }
@@ -259,16 +264,15 @@ stop_arm (struct PeerContext *p)
 
 
 static void
-exchange_hello_last (void *cls,
-                     const struct GNUNET_MessageHeader *message)
+exchange_hello_last (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
   GNUNET_assert (message != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d with peer (%s)!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d with peer (%s)!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
@@ -278,8 +282,7 @@ exchange_hello_last (void *cls,
 
 
 static void
-exchange_hello (void *cls,
-                const struct GNUNET_MessageHeader *message)
+exchange_hello (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
@@ -288,52 +291,47 @@ exchange_hello (void *cls,
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO of size %d from peer %s!\n", 
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              "Exchanging HELLO of size %d from peer %s!\n",
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 }
 
 
 
 static void
-end_badly (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (test_failed == GNUNET_NO)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Testcase timeout\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase timeout\n");
   else
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Reliability failed: Last message sent %u, Next message scheduled %u, Last message received %u, Message expected %u\n",
-                msg_sent,
-                msg_scheduled,
-                msg_recv,
-                msg_recv_expected);
-  
+                "Reliability failed: Last message sent %u, Next message scheduled %u, Last message received %u, Message expected %u\n",
+                msg_sent, msg_scheduled, msg_recv, msg_recv_expected);
+
   GNUNET_break (0);
   if (th_p2 != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(th_p2);
-      th_p2 = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
+    th_p2 = NULL;
+  }
   if (p2_hello_canceled == GNUNET_NO)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
-      p2_hello_canceled = GNUNET_YES;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
+    p2_hello_canceled = GNUNET_YES;
+  }
   if (p1_hello_canceled == GNUNET_NO)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
-      p1_hello_canceled = GNUNET_YES;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
+    p1_hello_canceled = GNUNET_YES;
+  }
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
   if (GNUNET_SCHEDULER_NO_TASK != tct)
-    {
-      GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+  }
   ok = 1;
 }
 
@@ -368,63 +366,56 @@ notify_receive (void *cls,
   char cbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
   const struct TestMessage *hdr;
 
-  hdr = (const struct TestMessage*) message;
+  hdr = (const struct TestMessage *) message;
 
   if (MTYPE != ntohs (message->type))
     return;
   msg_recv_expected = n;
-  msg_recv = ntohl(hdr->num);
-  s = get_size (ntohl(hdr->num));
+  msg_recv = ntohl (hdr->num);
+  s = get_size (ntohl (hdr->num));
 
   if (ntohs (message->size) != s)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  ntohl(hdr->num), s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                ntohl (hdr->num), s, ntohs (message->size), ntohl (hdr->num));
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
 
-  memset (cbuf, ntohl(hdr->num), s - sizeof (struct TestMessage));
-  if (0 != memcmp (cbuf,
-                   &hdr[1],
-                   s - sizeof (struct TestMessage)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u with bits %u, but body did not match\n",
-                  ntohl(hdr->num), (unsigned char) n);
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  memset (cbuf, ntohl (hdr->num), s - sizeof (struct TestMessage));
+  if (0 != memcmp (cbuf, &hdr[1], s - sizeof (struct TestMessage)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u with bits %u, but body did not match\n",
+                ntohl (hdr->num), (unsigned char) n);
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
 #if VERBOSE
-  if (ntohl(hdr->num) % 5 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Got message %u of size %u\n",
-                  ntohl (hdr->num),
-                  ntohs (message->size));
-    }
+  if (ntohl (hdr->num) % 5 == 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got message %u of size %u\n",
+                ntohl (hdr->num), ntohs (message->size));
+  }
 #endif
   n++;
-  set_bit(ntohl(hdr->num));
+  set_bit (ntohl (hdr->num));
   if (0 == (n % (TOTAL_MSGS / 100)))
-    {
-      fprintf (stderr, ".");
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly,
-                                               NULL);
-    }
+  {
+    fprintf (stderr, ".");
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+  }
   if (n == TOTAL_MSGS)
     end ();
 }
@@ -442,63 +433,62 @@ notify_ready (void *cls, size_t size, void *buf)
   th_p2 = NULL;
 
   if (buf == NULL)
-    {
-      GNUNET_break (0);
-      ok = 42;
-      return 0;
-    }
+  {
+    GNUNET_break (0);
+    ok = 42;
+    return 0;
+  }
   ret = 0;
   s = get_size (n);
   GNUNET_assert (size >= s);
   GNUNET_assert (buf != NULL);
   cbuf = buf;
   do
-    {
-      hdr.header.size = htons (s);
-      hdr.header.type = htons (MTYPE);
-      hdr.num = htonl (n);
-      msg_sent = n;
-      memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
-      ret += sizeof (struct TestMessage);
-      memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
-      ret += s - sizeof (struct TestMessage);
+  {
+    hdr.header.size = htons (s);
+    hdr.header.type = htons (MTYPE);
+    hdr.num = htonl (n);
+    msg_sent = n;
+    memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+    ret += sizeof (struct TestMessage);
+    memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
+    ret += s - sizeof (struct TestMessage);
 #if VERBOSE
-      if (n % 5000 == 0)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Sending message %u of size %u\n",
-                      n,
-                      s);
-        }
-#endif
-      n++;
-      s = get_size (n);
-      if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
-        break; /* sometimes pack buffer full, sometimes not */
+    if (n % 5000 == 0)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending message %u of size %u\n", n, s);
     }
+#endif
+    n++;
+    s = get_size (n);
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+      break;                    /* sometimes pack buffer full, sometimes not */
+  }
   while (size - ret >= s);
   if (n < TOTAL_MSGS)
   {
     th_p2 = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                            &p1.id,
-                                            s, 0, TIMEOUT,
-                                            &notify_ready,
-                                            NULL);
+                                                    &p1.id,
+                                                    s, 0, TIMEOUT,
+                                                    &notify_ready, NULL);
     msg_scheduled = n;
   }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "All messages scheduled to be sent!!\n");
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel(die_task);
-      die_task = GNUNET_SCHEDULER_add_delayed (UNRELIABLE_TIMEOUT, &end_unreliably, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "All messages scheduled to be sent!!\n");
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    die_task =
+        GNUNET_SCHEDULER_add_delayed (UNRELIABLE_TIMEOUT, &end_unreliably,
+                                      NULL);
+  }
   if (n % 5000 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Returning total message block of size %u\n",
-                  ret);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Returning total message block of size %u\n", ret);
+  }
   total_bytes += ret;
   return ret;
 }
@@ -511,14 +501,13 @@ notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
   connected--;
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
 #endif
   if (th_p2 != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
-      th_p2 = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
+    th_p2 = NULL;
+  }
 }
 
 
@@ -530,57 +519,57 @@ notify_connect (void *cls,
                 uint32_t ats_count)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n", 
-              GNUNET_i2s (peer), 
-              cls);
+              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
   if (cls == &p1)
+  {
+    GNUNET_TRANSPORT_set_quota (p1.th,
+                                &p2.id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+    start_time = GNUNET_TIME_absolute_get ();
+    connected++;
+  }
+  else
+  {
+    GNUNET_TRANSPORT_set_quota (p2.th,
+                                &p1.id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+    connected++;
+  }
+  if (2 == connected)
+  {
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
     {
-      GNUNET_TRANSPORT_set_quota (p1.th,
-                                  &p2.id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-      start_time = GNUNET_TIME_absolute_get ();
-      connected++;
+      GNUNET_SCHEDULER_cancel (die_task);
     }
-  else
+    if (GNUNET_SCHEDULER_NO_TASK != tct)
     {
-      GNUNET_TRANSPORT_set_quota (p2.th,
-                                  &p1.id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-      connected++;
+      GNUNET_SCHEDULER_cancel (tct);
+      tct = GNUNET_SCHEDULER_NO_TASK;
     }
-  if (2 == connected)
+    if (p2_hello_canceled == GNUNET_NO)
     {
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        {
-          GNUNET_SCHEDULER_cancel (die_task);     
-        }
-      if (GNUNET_SCHEDULER_NO_TASK != tct)
-        {
-          GNUNET_SCHEDULER_cancel (tct);
-          tct = GNUNET_SCHEDULER_NO_TASK;
-        }
-      if (p2_hello_canceled == GNUNET_NO)
-        {
-          GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
-          p2_hello_canceled = GNUNET_YES;
-        }
-      if (p1_hello_canceled == GNUNET_NO)
-        {
-          GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
-          p1_hello_canceled = GNUNET_YES;
-        }
-
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly, NULL);
-      GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                              &p1.id,
-                                              get_size (0), 0, TIMEOUT,
-                                              &notify_ready,
-                                              NULL);
-      
+      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
+      p2_hello_canceled = GNUNET_YES;
     }
+    if (p1_hello_canceled == GNUNET_NO)
+    {
+      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
+      p1_hello_canceled = GNUNET_YES;
+    }
+
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+    GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
+                                            &p1.id,
+                                            get_size (0), 0, TIMEOUT,
+                                            &notify_ready, NULL);
+
+  }
 }
 
 
@@ -591,31 +580,31 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
-    {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONFIGURATION_get_value_string (p->cfg,
-                                                            "PATHS", "SERVICEHOME", 
-                                                            &p->servicehome));
-      GNUNET_DISK_directory_remove (p->servicehome);
-    }
+  if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
+  {
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONFIGURATION_get_value_string (p->cfg,
+                                                          "PATHS",
+                                                          "SERVICEHOME",
+                                                          &p->servicehome));
+    GNUNET_DISK_directory_remove (p->servicehome);
+  }
 
 
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL,
-                                        "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE_ARM
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
 
   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
                                     p,
                                     &notify_receive,
-                                    &notify_connect,
-                                    &notify_disconnect);
+                                    &notify_connect, &notify_disconnect);
   GNUNET_assert (p->th != NULL);
 }
 
@@ -637,32 +626,32 @@ get_path_from_PATH (char *binary)
 
   p = getenv ("PATH");
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("PATH environment variable is unset.\n"));
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("PATH environment variable is unset.\n"));
+    return NULL;
+  }
   path = GNUNET_strdup (p);     /* because we write on it */
   buf = GNUNET_malloc (strlen (path) + 20);
   pos = path;
 
   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
-    {
-      *end = '\0';
-      sprintf (buf, "%s/%s", pos, binary);
-      if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-        {
-          GNUNET_free (path);
-          return buf;
-        }
-      pos = end + 1;
-    }
-  sprintf (buf, "%s/%s", pos, binary);
-  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    *end = '\0';
+    sprintf (buf, "%s/%s", pos, binary);
+    if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
     {
       GNUNET_free (path);
       return buf;
     }
+    pos = end + 1;
+  }
+  sprintf (buf, "%s/%s", pos, binary);
+  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    GNUNET_free (path);
+    return buf;
+  }
   GNUNET_free (buf);
   GNUNET_free (path);
   return NULL;
@@ -679,16 +668,18 @@ get_path_from_PATH (char *binary)
  *         can be run properly, GNUNET_NO otherwise
  */
 static int
-check_gnunet_nat_binary(char *binary)
+check_gnunet_nat_binary (char *binary)
 {
   struct stat statbuf;
   char *p;
+
 #ifdef MINGW
   SOCKET rawsock;
 #endif
 
 #ifdef MINGW
   char *binaryexe;
+
   GNUNET_asprintf (&binaryexe, "%s.exe", binary);
   p = get_path_from_PATH (binaryexe);
   free (binaryexe);
@@ -696,36 +687,34 @@ check_gnunet_nat_binary(char *binary)
   p = get_path_from_PATH (binary);
 #endif
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not find binary `%s' in PATH!\n"),
-                  binary);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not find binary `%s' in PATH!\n"), binary);
+    return GNUNET_NO;
+  }
   if (0 != STAT (p, &statbuf))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("stat (%s) failed: %s\n"),
-                  p,
-                  STRERROR (errno));
-      GNUNET_free (p);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("stat (%s) failed: %s\n"), p, STRERROR (errno));
+    GNUNET_free (p);
+    return GNUNET_SYSERR;
+  }
   GNUNET_free (p);
 #ifndef MINGW
-  if ( (0 != (statbuf.st_mode & S_ISUID)) &&
-       (statbuf.st_uid == 0) )
+  if ((0 != (statbuf.st_mode & S_ISUID)) && (statbuf.st_uid == 0))
     return GNUNET_YES;
   return GNUNET_NO;
 #else
   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (INVALID_SOCKET == rawsock)
-    {
-      DWORD err = GetLastError ();
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n", err);
-      return GNUNET_NO; /* not running as administrator */
-    }
+  {
+    DWORD err = GetLastError ();
+
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n",
+                err);
+    return GNUNET_NO;           /* not running as administrator */
+  }
   closesocket (rawsock);
   return GNUNET_YES;
 #endif
@@ -733,18 +722,13 @@ check_gnunet_nat_binary(char *binary)
 
 
 static void
-try_connect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking peers to connect...\n");
-  GNUNET_TRANSPORT_try_connect (p2.th,
-                                &p1.id);
-  GNUNET_TRANSPORT_try_connect (p1.th,
-                                &p2.id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking peers to connect...\n");
+  GNUNET_TRANSPORT_try_connect (p2.th, &p1.id);
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
   tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                      &try_connect,
-                                      NULL);
+                                      &try_connect, NULL);
 }
 
 
@@ -754,48 +738,46 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly,
-                                           NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
   if (is_tcp)
-    {
-      setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
-      setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
+    setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
+  }
   else if (is_http)
-    {
-      setup_peer (&p1, "test_transport_api_rel_http_peer1.conf");
-      setup_peer (&p2, "test_transport_api_rel_http_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_rel_http_peer1.conf");
+    setup_peer (&p2, "test_transport_api_rel_http_peer2.conf");
+  }
   else if (is_https)
-    {
-      setup_peer (&p1, "test_transport_api_rel_https_peer1.conf");
-      setup_peer (&p2, "test_transport_api_rel_https_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_rel_https_peer1.conf");
+    setup_peer (&p2, "test_transport_api_rel_https_peer2.conf");
+  }
   else if (is_udp)
-    {
-      setup_peer (&p1, "test_transport_api_udp_peer1.conf");
-      setup_peer (&p2, "test_transport_api_udp_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_udp_peer1.conf");
+    setup_peer (&p2, "test_transport_api_udp_peer2.conf");
+  }
   else if (is_unix)
-    {
-      setup_peer (&p1, "test_transport_api_unix_peer1.conf");
-      setup_peer (&p2, "test_transport_api_unix_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_unix_peer1.conf");
+    setup_peer (&p2, "test_transport_api_unix_peer2.conf");
+  }
   else if (is_tcp_nat)
-    {
-      setup_peer (&p1, "test_transport_api_tcp_nat_peer1.conf");
-      setup_peer (&p2, "test_transport_api_tcp_nat_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_tcp_nat_peer1.conf");
+    setup_peer (&p2, "test_transport_api_tcp_nat_peer2.conf");
+  }
   else if (is_wlan)
-    {
-      setup_peer (&p1, "test_transport_api_wlan_peer1.conf");
-      setup_peer (&p2, "test_transport_api_wlan_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_wlan_peer1.conf");
+    setup_peer (&p2, "test_transport_api_wlan_peer2.conf");
+  }
   else
     GNUNET_assert (0);
-  GNUNET_assert(p1.th != NULL);
-  GNUNET_assert(p2.th != NULL);
+  GNUNET_assert (p1.th != NULL);
+  GNUNET_assert (p2.th != NULL);
   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
   p1_hello_canceled = GNUNET_NO;
   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
@@ -820,15 +802,17 @@ check ()
   };
 
 #if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
+  setTransportOptions ("test_transport_api_data.conf");
 #endif
   ok = 1;
 
-  if ((GNUNET_YES == is_tcp_nat) && (check_gnunet_nat_binary("gnunet-nat-server") != GNUNET_YES))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Not running NAT test case, binaries not properly installed.\n");
-      return 0;
-    }
+  if ((GNUNET_YES == is_tcp_nat) &&
+      (check_gnunet_nat_binary ("gnunet-nat-server") != GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Not running NAT test case, binaries not properly installed.\n");
+    return 0;
+  }
 
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
                       argv, "test-transport-api-unreliability", "nohelp",
@@ -839,53 +823,66 @@ check ()
   if (is_https)
   {
     struct stat sbuf;
-    if (0 == stat (cert_file_p1, &sbuf ))
+
+    if (0 == stat (cert_file_p1, &sbuf))
     {
-      if (0 == remove(cert_file_p1))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed existing certificate file `%s'\n",cert_file_p1);
+      if (0 == remove (cert_file_p1))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed existing certificate file `%s'\n",
+                    cert_file_p1);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",cert_file_p1);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",
+                    cert_file_p1);
     }
 
-    if (0 == stat (key_file_p1, &sbuf ))
+    if (0 == stat (key_file_p1, &sbuf))
     {
-      if (0 == remove(key_file_p1))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed private key file `%s'\n",key_file_p1);
+      if (0 == remove (key_file_p1))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed private key file `%s'\n",
+                    key_file_p1);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to private key file `%s'\n",key_file_p1);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Failed to private key file `%s'\n", key_file_p1);
     }
 
-    if (0 == stat (cert_file_p2, &sbuf ))
+    if (0 == stat (cert_file_p2, &sbuf))
     {
-      if (0 == remove(cert_file_p2))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed existing certificate file `%s'\n",cert_file_p2);
+      if (0 == remove (cert_file_p2))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed existing certificate file `%s'\n",
+                    cert_file_p2);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",cert_file_p2);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",
+                    cert_file_p2);
     }
 
-    if (0 == stat (key_file_p2, &sbuf ))
+    if (0 == stat (key_file_p2, &sbuf))
     {
-      if (0 == remove(key_file_p2))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed private key file `%s'\n",key_file_p2);
+      if (0 == remove (key_file_p2))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed private key file `%s'\n",
+                    key_file_p2);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to private key file `%s'\n",key_file_p2);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Failed to private key file `%s'\n", key_file_p2);
     }
-    GNUNET_free(key_file_p1);
-    GNUNET_free(key_file_p2);
-    GNUNET_free(cert_file_p1);
-    GNUNET_free(cert_file_p2);
+    GNUNET_free (key_file_p1);
+    GNUNET_free (key_file_p2);
+    GNUNET_free (cert_file_p1);
+    GNUNET_free (cert_file_p2);
   }
 
-  if (p1.servicehome != NULL) 
-    {
-      GNUNET_DISK_directory_remove (p1.servicehome);
-      GNUNET_free(p1.servicehome);
-    }
+  if (p1.servicehome != NULL)
+  {
+    GNUNET_DISK_directory_remove (p1.servicehome);
+    GNUNET_free (p1.servicehome);
+  }
   if (p2.servicehome != NULL)
-    {
-      GNUNET_DISK_directory_remove (p2.servicehome); 
-      GNUNET_free(p2.servicehome);
-    }
+  {
+    GNUNET_DISK_directory_remove (p2.servicehome);
+    GNUNET_free (p2.servicehome);
+  }
   return ok;
 }
 
@@ -900,40 +897,40 @@ main (int argc, char *argv[])
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-2");
 
-  if (strstr(argv[0], "tcp_nat") != NULL)
-    {
-      is_tcp_nat = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "tcp_nat");
-    }
-  else if (strstr(argv[0], "tcp") != NULL)
-    {
-      is_tcp = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "tcp");
-    }
-  else if (strstr(argv[0], "https") != NULL)
-    {
-      is_https = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "https");
-    }
-  else if (strstr(argv[0], "http") != NULL)
-    {
-      is_http = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "http");
-    }
-  else if (strstr(argv[0], "udp") != NULL)
-    {
-      is_udp = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "udp");
-    }
-  else if (strstr(argv[0], "unix") != NULL)
-    {
-      is_unix = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "unix");
-    }
-  else if (strstr(argv[0], "wlan") != NULL)
-    {
-       is_wlan = GNUNET_YES;
-    }
+  if (strstr (argv[0], "tcp_nat") != NULL)
+  {
+    is_tcp_nat = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "tcp_nat");
+  }
+  else if (strstr (argv[0], "tcp") != NULL)
+  {
+    is_tcp = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "tcp");
+  }
+  else if (strstr (argv[0], "https") != NULL)
+  {
+    is_https = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "https");
+  }
+  else if (strstr (argv[0], "http") != NULL)
+  {
+    is_http = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "http");
+  }
+  else if (strstr (argv[0], "udp") != NULL)
+  {
+    is_udp = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "udp");
+  }
+  else if (strstr (argv[0], "unix") != NULL)
+  {
+    is_unix = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "unix");
+  }
+  else if (strstr (argv[0], "wlan") != NULL)
+  {
+    is_wlan = GNUNET_YES;
+  }
   GNUNET_log_setup ("test-transport-api-unreliability",
 #if VERBOSE
                     "DEBUG",
@@ -943,7 +940,7 @@ main (int argc, char *argv[])
                     NULL);
   ret = check ();
 
-  GNUNET_free_non_null(test_name);
+  GNUNET_free_non_null (test_name);
   return ret;
 }
 
diff --git a/src/transport/test_transport_ats.c b/src/transport/test_transport_ats.c
index bf7bc0fe5..d9e4b23d5 100644
--- a/src/transport/test_transport_ats.c
+++ b/src/transport/test_transport_ats.c
@@ -28,18 +28,17 @@
 
 #define VERBOSE GNUNET_YES
 
-static struct ATS_Handle * ats;
+static struct ATS_Handle *ats;
 
-static struct GNUNET_CONFIGURATION_Handle * cfg;
+static struct GNUNET_CONFIGURATION_Handle *cfg;
 
 static struct TransportConfiguration *tc;
 
 
-static void 
+static void
 ats_result_cb ()
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-      "ATS Result callback\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS Result callback\n");
 }
 
 struct TransportConfiguration
@@ -47,35 +46,35 @@ struct TransportConfiguration
   int peers;
   int mechanisms;
 
-  struct ATS_peer * p_head;
-  struct ATS_peer * p_tail;
+  struct ATS_peer *p_head;
+  struct ATS_peer *p_tail;
 
-  struct ATS_mechanism * m_head;
-  struct ATS_mechanism * m_tail;
+  struct ATS_mechanism *m_head;
+  struct ATS_mechanism *m_tail;
 };
 
 
-static void 
-create_ats_information (struct ATS_peer **p, int * c_p,
-                        struct ATS_mechanism ** m, int * c_m)
-{ 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-      "ATS needs addresses\n");
+static void
+create_ats_information (struct ATS_peer **p, int *c_p,
+                        struct ATS_mechanism **m, int *c_m)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS needs addresses\n");
 
- (*p) = tc->p_head;
- (*c_p) = tc->mechanisms;
- (*m) = tc->m_head;
- (*c_m) = tc->mechanisms;
+  (*p) = tc->p_head;
+  (*c_p) = tc->mechanisms;
+  (*m) = tc->m_head;
+  (*c_m) = tc->mechanisms;
 }
 
 
-static
-int run_ats ()
+static int
+run_ats ()
 {
   int ret = 0;
+
   ats_calculate_bandwidth_distribution (ats);
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Running ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
+              "Running ATS: %s \n", (ret == 0) ? "SUCCESSFUL" : "FAILED");
   return ret;
 }
 
@@ -84,96 +83,96 @@ static int
 init_ats ()
 {
   int ret = 0;
-  ats = ats_init(1.0, 1.0, 1.0, 50000, 5, 10, ATS_MAX_EXEC_DURATION,
-                create_ats_information,
-                ats_result_cb);
+
+  ats = ats_init (1.0, 1.0, 1.0, 50000, 5, 10, ATS_MAX_EXEC_DURATION,
+                  create_ats_information, ats_result_cb);
   //GNUNET_assert (ats != NULL);
 
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Initializing ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
+              "Initializing ATS: %s \n", (ret == 0) ? "SUCCESSFUL" : "FAILED");
   return ret;
 }
 
 
-static int 
+static int
 shutdown_ats ()
 {
   int ret = 0;
+
   ats_delete_problem (ats);
   ats_shutdown (ats);
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Shutdown ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
+              "Shutdown ATS: %s \n", (ret == 0) ? "SUCCESSFUL" : "FAILED");
   return ret;
 }
 
 
 /* To make compiler happy */
-void 
-dummy()
+void
+dummy ()
 {
-  struct ATS_quality_metric * q = qm;
+  struct ATS_quality_metric *q = qm;
+
   q = NULL;
-  struct ATS_ressource * r = ressources;
+  struct ATS_ressource *r = ressources;
+
   r = NULL;
-  q++; 
+  q++;
   r++;
 }
 
 
-static void 
+static void
 iterate_peer_values (void *cls,
-                     const char *section,
-                     const char *option,
-                     const char *value)
+                     const char *section, const char *option, const char *value)
 {
   if (strcmp (option, "f") == 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "\t %s %s\n", option, value);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "\t %s %s\n", option, value);
 }
 
 static void
 iterate_mech_values (void *cls,
-                     const char *section,
-                     const char *option,
-                     const char *value)
+                     const char *section, const char *option, const char *value)
 {
   if (strcmp (option, "f") == 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "\t %s %s\n", option, value);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "\t %s %s\n", option, value);
 }
 
-static void 
-iterate_sections (void *cls,
-                  const char *section)
+static void
+iterate_sections (void *cls, const char *section)
 {
-  struct TransportConfiguration * tc = cls;
+  struct TransportConfiguration *tc = cls;
+
   /* Peer definition */
-  if (99 == strlen(section))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Peer '%s`\n", section);
-      GNUNET_HashCode h;
-      int res =GNUNET_CRYPTO_hash_from_string(section, &h);
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "HASH '%s` %i\n", GNUNET_h2s (&h), res);
-      GNUNET_CONFIGURATION_iterate_section_values(cfg, section, iterate_peer_values, NULL);
-      tc->peers++;
-    }
-  if (10 == strlen(section))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Mechanism '%s`\n",section);
-      GNUNET_CONFIGURATION_iterate_section_values(cfg, section, iterate_mech_values, NULL);
-      tc->peers++;
-    }
+  if (99 == strlen (section))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Peer '%s`\n", section);
+    GNUNET_HashCode h;
+    int res = GNUNET_CRYPTO_hash_from_string (section, &h);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "HASH '%s` %i\n", GNUNET_h2s (&h), res);
+    GNUNET_CONFIGURATION_iterate_section_values (cfg, section,
+                                                 iterate_peer_values, NULL);
+    tc->peers++;
+  }
+  if (10 == strlen (section))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Mechanism '%s`\n", section);
+    GNUNET_CONFIGURATION_iterate_section_values (cfg, section,
+                                                 iterate_mech_values, NULL);
+    tc->peers++;
+  }
 }
 
 
-static struct TransportConfiguration * 
-load_transport_configuration (char * filename)
+static struct TransportConfiguration *
+load_transport_configuration (char *filename)
 {
-  struct TransportConfiguration * ret = GNUNET_malloc(sizeof (struct TransportConfiguration));
+  struct TransportConfiguration *ret =
+      GNUNET_malloc (sizeof (struct TransportConfiguration));
 
-  cfg = GNUNET_CONFIGURATION_create();
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONFIGURATION_load(cfg, filename));
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, filename));
   GNUNET_CONFIGURATION_iterate_sections (cfg, iterate_sections, ret);
   GNUNET_CONFIGURATION_destroy (cfg);
   cfg = NULL;
diff --git a/src/transport/test_transport_ats_multiple_peers.c b/src/transport/test_transport_ats_multiple_peers.c
index 9d30a061d..d060a4d4b 100644
--- a/src/transport/test_transport_ats_multiple_peers.c
+++ b/src/transport/test_transport_ats_multiple_peers.c
@@ -46,17 +46,17 @@ static int peers_left;
 static int failed_peers;
 
 static int measurement_started = GNUNET_NO;
-static char * config_file;
+static char *config_file;
 
 static struct GNUNET_TESTING_PeerGroup *pg;
 
 static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
 static GNUNET_SCHEDULER_TaskIdentifier stats_task;
 static GNUNET_SCHEDULER_TaskIdentifier send_task;
-struct GNUNET_TESTING_Daemon * master_deamon;
-struct GNUNET_TESTING_Daemon * ping_deamon;
+struct GNUNET_TESTING_Daemon *master_deamon;
+struct GNUNET_TESTING_Daemon *ping_deamon;
 
-struct GNUNET_STATISTICS_Handle * stats;
+struct GNUNET_STATISTICS_Handle *stats;
 
 struct TEST_result
 {
@@ -87,21 +87,21 @@ static int force_rebuild;
 static int send_msg;
 static int machine_parsable;
 
-static struct TEST_result results_new       [MEASUREMENTS+1];
-static struct TEST_result results_modified  [MEASUREMENTS+1];
-static struct TEST_result results_unmodified[MEASUREMENTS+1];
+static struct TEST_result results_new[MEASUREMENTS + 1];
+static struct TEST_result results_modified[MEASUREMENTS + 1];
+static struct TEST_result results_unmodified[MEASUREMENTS + 1];
 static struct TEST_result current;
 
-static struct GNUNET_STATISTICS_GetHandle * s_solution;
-static struct GNUNET_STATISTICS_GetHandle * s_time;
-static struct GNUNET_STATISTICS_GetHandle * s_peers;
-static struct GNUNET_STATISTICS_GetHandle * s_mechs;
-static struct GNUNET_STATISTICS_GetHandle * s_duration;
-static struct GNUNET_STATISTICS_GetHandle * s_invalid;
-static struct GNUNET_STATISTICS_GetHandle * s_state;
+static struct GNUNET_STATISTICS_GetHandle *s_solution;
+static struct GNUNET_STATISTICS_GetHandle *s_time;
+static struct GNUNET_STATISTICS_GetHandle *s_peers;
+static struct GNUNET_STATISTICS_GetHandle *s_mechs;
+static struct GNUNET_STATISTICS_GetHandle *s_duration;
+static struct GNUNET_STATISTICS_GetHandle *s_invalid;
+static struct GNUNET_STATISTICS_GetHandle *s_state;
 
-struct GNUNET_TRANSPORT_TransmitHandle * t;
-struct GNUNET_TRANSPORT_Handle * th;
+struct GNUNET_TRANSPORT_TransmitHandle *t;
+struct GNUNET_TRANSPORT_Handle *th;
 
 /**
  * Check whether peers successfully shut down.
@@ -110,463 +110,459 @@ static void
 shutdown_callback (void *cls, const char *emsg)
 {
   if (emsg != NULL)
-    {
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Shutdown of peers failed!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown of peers failed!\n");
 #endif
-      if (ok == 0)
-        ok = 666;
-    }
+    if (ok == 0)
+      ok = 666;
+  }
   else
-    {
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers successfully shut down!\n");
-        if (stats != NULL)
-                GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
-        stats = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully shut down!\n");
+    if (stats != NULL)
+      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
 #endif
-    }
+  }
 }
 
 static void
-shutdown_peers()
+shutdown_peers ()
 {
   if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(shutdown_task);
-      shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (shutdown_task);
+    shutdown_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(stats_task);
-      stats_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (stats_task);
+    stats_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (send_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  
+  {
+    GNUNET_SCHEDULER_cancel (send_task);
+    send_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+
   if (t != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
-  GNUNET_TRANSPORT_disconnect(th);  
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
+    t = NULL;
+  }
+  GNUNET_TRANSPORT_disconnect (th);
   if (s_time != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_time);
-      s_time = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_time);
+    s_time = NULL;
+  }
   if (s_peers != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_peers);
-      s_peers = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_peers);
+    s_peers = NULL;
+  }
   if (s_mechs != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_mechs);
-      s_mechs = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_mechs);
+    s_mechs = NULL;
+  }
   if (s_solution != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_solution);
-      s_solution = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_solution);
+    s_solution = NULL;
+  }
   if (s_duration != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_duration);
-      s_duration = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_duration);
+    s_duration = NULL;
+  }
   if (s_invalid != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_invalid);
-      s_invalid = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_invalid);
+    s_invalid = NULL;
+  }
   if (s_state != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_state);
-      s_state = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_state);
+    s_state = NULL;
+  }
   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 }
 
-static void 
-evaluate_measurements()
+static void
+evaluate_measurements ()
 {
   int c;
+
   //int mechs = 0;
   double average[3];
   double stddev[3];
+
   //char * output;
   c = 1;
-  
+
   //GNUNET_asprintf(&output, "p,%i,m,%i,",peers, MEASUREMENTS, results_modified[0].mechs,
-  
+
   average[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      average[0] += (double) results_new[c].duration;
-    }
+  for (c = 0; c < c_new; c++)
+  {
+    average[0] += (double) results_new[c].duration;
+  }
   average[0] /= c_new;
-  
+
   stddev[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      stddev[0] += (results_new[c].duration - average[0]) *
-          (results_new[c].duration - average[0]);
-    }
+  for (c = 0; c < c_new; c++)
+  {
+    stddev[0] += (results_new[c].duration - average[0]) *
+        (results_new[c].duration - average[0]);
+  }
   stddev[0] /= c_new;
   stddev[0] = sqrt (stddev[0]);
   if (!machine_parsable)
     fprintf (stderr,
-             "new, %i measurements, average: %f stddev: %f\n",
-             c_new, average[0], stddev[0]);
-  
+             "new, %i measurements, average: %f stddev: %f\n",
+             c_new, average[0], stddev[0]);
+
   average[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      average[1] += (double) results_modified[c].duration;
-    }
+  for (c = 0; c < c_modified; c++)
+  {
+    average[1] += (double) results_modified[c].duration;
+  }
   average[1] /= c_modified;
-  
+
   stddev[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      stddev[1] += (results_modified[c].duration - average[1]) *
-          (results_modified[c].duration - average[1]);
-    }
+  for (c = 0; c < c_modified; c++)
+  {
+    stddev[1] += (results_modified[c].duration - average[1]) *
+        (results_modified[c].duration - average[1]);
+  }
   stddev[1] /= c_modified;
   stddev[1] = sqrt (stddev[1]);
-  if (!machine_parsable) 
+  if (!machine_parsable)
     fprintf (stderr,
-             "modified, %i measurements, average: %f stddev: %f\n",
-             c_modified, average[1], stddev[1]);
-  
+             "modified, %i measurements, average: %f stddev: %f\n",
+             c_modified, average[1], stddev[1]);
+
   average[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      average[2] += (double) results_unmodified[c].duration;
-    }
+  for (c = 0; c < c_unmodified; c++)
+  {
+    average[2] += (double) results_unmodified[c].duration;
+  }
   average[2] /= c_unmodified;
   stddev[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      stddev[2] += (results_unmodified[c].duration - average[2]) *
-          (results_unmodified[c].duration - average[2]);
-    }
+  for (c = 0; c < c_unmodified; c++)
+  {
+    stddev[2] += (results_unmodified[c].duration - average[2]) *
+        (results_unmodified[c].duration - average[2]);
+  }
   stddev[2] /= c_unmodified;
   stddev[2] = sqrt (stddev[2]);
-  
-  if (!machine_parsable) 
+
+  if (!machine_parsable)
     fprintf (stderr,
-             "unmodified, %i measurements, average: %f stddev: %f\n",
-             c_unmodified, average[2], stddev[2]);
-  
+             "unmodified, %i measurements, average: %f stddev: %f\n",
+             c_unmodified, average[2], stddev[2]);
+
   if (machine_parsable)
     fprintf (stderr,
-             "peers,%i,mechs,%llu,"
-             "new,%i,%f,%f,"
-             "mod,%i,%f,%f,"
-             "unmod,%i,%f,%f\n",
-             peers-1, (unsigned long long) results_unmodified[0].mechs,
-             c_new, average[0], stddev[0],
-             c_modified, average[1], stddev[1],
-             c_unmodified, average[2], stddev[2]);
-  shutdown_peers();
+             "peers,%i,mechs,%llu,"
+             "new,%i,%f,%f,"
+             "mod,%i,%f,%f,"
+             "unmod,%i,%f,%f\n",
+             peers - 1, (unsigned long long) results_unmodified[0].mechs,
+             c_new, average[0], stddev[0],
+             c_modified, average[1], stddev[1],
+             c_unmodified, average[2], stddev[2]);
+  shutdown_peers ();
 }
 
 
-static int 
+static int
 stats_cb (void *cls,
-          const char *subsystem,
-          const char *name,
-          uint64_t value,
-          int is_persistent)
+          const char *subsystem,
+          const char *name, uint64_t value, int is_persistent)
 {
   static int printed = GNUNET_NO;
+
 #if VERBOSE_ATS
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name ,value);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name, value);
 #endif
-  if (0 == strcmp (name,"ATS invalid solutions"))
-    {
-      if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel(stats_task);
-          stats_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"MLP produced invalid %llu result(s)!\n",
-          value);
-      shutdown_peers();
-      return GNUNET_SYSERR;
-    }
-  
-  if (0 == strcmp (name,"ATS solution"))
+  if (0 == strcmp (name, "ATS invalid solutions"))
+  {
+    if (stats_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      s_solution = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS peers"))
-    {
-      s_peers = NULL;
+      GNUNET_SCHEDULER_cancel (stats_task);
+      stats_task = GNUNET_SCHEDULER_NO_TASK;
     }
-  
-  if (0 == strcmp (name,"ATS mechanisms"))
-    {
-      s_mechs = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MLP produced invalid %llu result(s)!\n", value);
+    shutdown_peers ();
+    return GNUNET_SYSERR;
+  }
+
+  if (0 == strcmp (name, "ATS solution"))
+  {
+    s_solution = NULL;
+  }
+
+  if (0 == strcmp (name, "ATS peers"))
+  {
+    s_peers = NULL;
+  }
+
+  if (0 == strcmp (name, "ATS mechanisms"))
+  {
+    s_mechs = NULL;
+  }
+
+  if (0 == strcmp (name, "ATS duration"))
+  {
+    s_duration = NULL;
+  }
+  if (0 == strcmp (name, "ATS timestamp"))
+  {
+    s_time = NULL;
+  }
+  if (0 == strcmp (name, "ATS state"))
+  {
+    s_state = NULL;
+  }
+
+  if ((measurement_started == GNUNET_NO) &&
+      (0 == strcmp (name, "ATS peers")) && (value == peers - 1))
+  {
+    measurement_started = GNUNET_YES;
+    count = 1;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All %llu peers connected\n", value);
+#if !VERBOSE
+    if (!machine_parsable)
+      fprintf (stderr, "%i", count);
+#endif
+  }
+
+  if (measurement_started == GNUNET_YES)
+  {
+    // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
+    if (0 == strcmp (name, "ATS timestamp"))
+    {
+      if (current.timestamp == 0)
+      {
+        printed = GNUNET_NO;
+        current.timestamp = value;
+      }
+      if (current.timestamp == value)
+      {
+        printed = GNUNET_YES;
+      }
+      if (current.timestamp != value)
+      {
+        if (current.state == ATS_NEW)
+        {
+          if (c_new < MEASUREMENTS)
+          {
+            results_new[c_new] = current;
+            c_new++;
+          }
+          else
+          {
+            force_rebuild = GNUNET_NO;
+            force_q_updates = GNUNET_NO;
+            send_msg = GNUNET_NO;
+          }
+        }
+        if (current.state == ATS_UNMODIFIED)
+        {
+          if (c_unmodified < MEASUREMENTS)
+          {
+            results_unmodified[c_unmodified] = current;
+            c_unmodified++;
+          }
+
+        }
+        if (current.state == ATS_QUALITY_UPDATED)
+        {
+          if (c_modified < MEASUREMENTS)
+          {
+            results_modified[c_modified] = current;
+            c_modified++;
+          }
+          else
+          {
+            force_q_updates = GNUNET_NO;
+            force_rebuild = GNUNET_YES;
+          }
+        }
+        count++;
+#if VERBOSE
+        fprintf (stderr,
+                 "(new: %i / modified: %i / unmodified: %i) of %i \n",
+                 c_new, c_modified, c_unmodified, MEASUREMENTS);
+#endif
+        if ((c_modified >= MEASUREMENTS) &&
+            (c_new >= MEASUREMENTS) && (c_unmodified >= MEASUREMENTS))
+        {
+#if !VERBOSE
+          if (!machine_parsable)
+            fprintf (stdout, "\n");
+#endif
+          if (stats_task != GNUNET_SCHEDULER_NO_TASK)
+          {
+            GNUNET_SCHEDULER_cancel (stats_task);
+            stats_task = GNUNET_SCHEDULER_NO_TASK;
+          }
+          evaluate_measurements ();
+          return GNUNET_SYSERR;
+        }
+
+        printed = GNUNET_NO;
+        current.timestamp = value;
+#if !VERBOSE
+        if (!machine_parsable)
+          fprintf (stderr, "..%i", count);
+#endif
+        return GNUNET_OK;
+      }
     }
-  
-  if (0 == strcmp (name,"ATS duration"))
+
+    if (0 == strcmp (name, "ATS solution"))
     {
-      s_duration = NULL;
+      current.solution = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  if (0 == strcmp (name,"ATS timestamp"))
+
+    if (0 == strcmp (name, "ATS peers"))
     {
-      s_time = NULL;
+      current.peers = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  if (0 == strcmp (name,"ATS state"))
+
+    if (0 == strcmp (name, "ATS mechanisms"))
     {
-      s_state = NULL;
+      current.mechs = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  
-  if ( (measurement_started == GNUNET_NO) && 
-       (0 == strcmp (name, "ATS peers")) && 
-       (value == peers-1) )
+
+    if (0 == strcmp (name, "ATS duration"))
     {
-      measurement_started = GNUNET_YES;
-      count = 1;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "All %llu peers connected\n", 
-                  value);
-#if !VERBOSE
-      if (! machine_parsable)   
-        fprintf(stderr, "%i", count);
-#endif
+      current.duration = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  
-  if (measurement_started == GNUNET_YES)
+    if (0 == strcmp (name, "ATS state"))
     {
-      // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
-      if (0 == strcmp (name,"ATS timestamp"))
-        {
-          if (current.timestamp == 0)
-            {
-              printed = GNUNET_NO;
-              current.timestamp = value;
-            }
-          if (current.timestamp == value)
-            {
-              printed = GNUNET_YES;
-            }
-          if (current.timestamp != value)
-            {
-              if (current.state == ATS_NEW)
-                {
-                  if (c_new < MEASUREMENTS)
-                    {
-                      results_new[c_new] = current;
-                      c_new++;
-                    }
-                  else
-                    {
-                      force_rebuild = GNUNET_NO;
-                      force_q_updates = GNUNET_NO;
-                      send_msg = GNUNET_NO;
-                    }
-                }
-              if (current.state == ATS_UNMODIFIED)
-                {
-                  if (c_unmodified < MEASUREMENTS)
-                    {
-                      results_unmodified[c_unmodified] = current;
-                      c_unmodified++;
-                    }
-                  
-                }
-              if (current.state == ATS_QUALITY_UPDATED)
-                {
-                  if (c_modified < MEASUREMENTS)
-                    {
-                      results_modified[c_modified] = current;
-                      c_modified++;
-                    }
-                  else
-                    {
-                      force_q_updates = GNUNET_NO;
-                      force_rebuild = GNUNET_YES;
-                    }
-                }
-              count ++;
-#if VERBOSE
-              fprintf (stderr,
-                       "(new: %i / modified: %i / unmodified: %i) of %i \n", 
-                       c_new, c_modified, c_unmodified , MEASUREMENTS);
-#endif
-              if ((c_modified >= MEASUREMENTS) &&
-                  (c_new >= MEASUREMENTS) &&
-                  (c_unmodified >= MEASUREMENTS))
-                {
-#if !VERBOSE
-                  if (!machine_parsable)
-                    fprintf(stdout, "\n");
-#endif
-                  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-                    {
-                      GNUNET_SCHEDULER_cancel(stats_task);
-                      stats_task = GNUNET_SCHEDULER_NO_TASK;
-                    }
-                  evaluate_measurements();
-                  return GNUNET_SYSERR;
-                }
-              
-              printed = GNUNET_NO;
-              current.timestamp = value;
-#if !VERBOSE
-              if (! machine_parsable)
-                fprintf(stderr, "..%i", count);
-#endif
-              return GNUNET_OK;
-            }
-        }
-      
-      if (0 == strcmp (name,"ATS solution"))
-        {
-          current.solution = value;
-          if (printed == GNUNET_NO)
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      
-      if (0 == strcmp (name,"ATS peers"))
-        {
-          current.peers = value;
-          if (printed == GNUNET_NO)
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      
-      if (0 == strcmp (name,"ATS mechanisms"))
-        {
-          current.mechs = value;
-          if (printed == GNUNET_NO) 
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      
-      if (0 == strcmp (name,"ATS duration"))
-        {
-          current.duration = value;
-          if (printed == GNUNET_NO) 
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      if (0 == strcmp (name,"ATS state"))
-        {
-          current.state = value;
-          const char * cont;
-          switch (value)
-            {
-            case ATS_NEW:
-              cont = "NEW";
-              break;
-            case ATS_COST_UPDATED:
-              cont = "C_UPDATED";
-              break;
-            case ATS_QUALITY_UPDATED:
-              cont = "Q_UPDATED";
-              break;
-            case ATS_QUALITY_COST_UPDATED:
-              cont = "QC_UPDATED";
-              break;
-            case ATS_UNMODIFIED:
-              cont = "UNMODIFIED";
-              break;
-            default:
-              GNUNET_break (0);
-              cont = "<undefined>";
-              break;
-            }
-          if (printed == GNUNET_NO) 
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                        "[%i] ATS state: %s\n", 
-                        count, 
-                        cont);
-        }
+      current.state = value;
+      const char *cont;
+
+      switch (value)
+      {
+      case ATS_NEW:
+        cont = "NEW";
+        break;
+      case ATS_COST_UPDATED:
+        cont = "C_UPDATED";
+        break;
+      case ATS_QUALITY_UPDATED:
+        cont = "Q_UPDATED";
+        break;
+      case ATS_QUALITY_COST_UPDATED:
+        cont = "QC_UPDATED";
+        break;
+      case ATS_UNMODIFIED:
+        cont = "UNMODIFIED";
+        break;
+      default:
+        GNUNET_break (0);
+        cont = "<undefined>";
+        break;
+      }
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "[%i] ATS state: %s\n", count, cont);
     }
+  }
   return GNUNET_OK;
 }
 
 
 static void
-stats_get_task (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+stats_get_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   stats_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
-  
+
   s_time = GNUNET_STATISTICS_get (stats, "transport", "ATS timestamp",
-      TIMEOUT, NULL, &stats_cb, NULL);
+                                  TIMEOUT, NULL, &stats_cb, NULL);
   s_solution = GNUNET_STATISTICS_get (stats, "transport", "ATS solution",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  s_duration = GNUNET_STATISTICS_get (stats, "transport","ATS duration",
-      TIMEOUT, NULL, &stats_cb, NULL);
+                                      TIMEOUT, NULL, &stats_cb, NULL);
+  s_duration = GNUNET_STATISTICS_get (stats, "transport", "ATS duration",
+                                      TIMEOUT, NULL, &stats_cb, NULL);
   s_peers = GNUNET_STATISTICS_get (stats, "transport", "ATS peers",
-      TIMEOUT, NULL, &stats_cb, NULL);
+                                   TIMEOUT, NULL, &stats_cb, NULL);
   s_mechs = GNUNET_STATISTICS_get (stats, "transport", "ATS mechanisms",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  s_invalid = GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  s_state = GNUNET_STATISTICS_get (stats, "transport", "ATS state",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  
-  stats_task = GNUNET_SCHEDULER_add_delayed(
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
-      &stats_get_task,
-      NULL);
+                                   TIMEOUT, NULL, &stats_cb, NULL);
+  s_invalid =
+      GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions",
+                             TIMEOUT, NULL, &stats_cb, NULL);
+  s_state =
+      GNUNET_STATISTICS_get (stats, "transport", "ATS state", TIMEOUT, NULL,
+                             &stats_cb, NULL);
+
+  stats_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MILLISECONDS, 100),
+                                    &stats_get_task, NULL);
 }
 
 
 static void
-delay (void *cls,
-       const struct GNUNET_SCHEDULER_TaskContext *tc)
+delay (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
 #if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-              "Delay over\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Delay over\n");
 #endif
   shutdown_peers ();
 }
 
 static void
-connect_peers()
+connect_peers ()
 {
-  shutdown_task = GNUNET_SCHEDULER_add_delayed(DELAY, &delay, NULL);
+  shutdown_task = GNUNET_SCHEDULER_add_delayed (DELAY, &delay, NULL);
 }
 
 
 /* To make compiler happy */
-void dummy(void)
+void
+dummy (void)
 {
-  struct ATS_quality_metric * q = qm;
+  struct ATS_quality_metric *q = qm;
+
   q = NULL;
   q++;
-  struct ATS_ressource * r = ressources;
+  struct ATS_ressource *r = ressources;
+
   r = NULL;
   r++;
 }
 
-static size_t 
+static size_t
 send_dummy_data_task (void *cls, size_t size, void *buf)
 {
   int s = sizeof (struct TestMessage);
   struct TestMessage hdr;
-  
+
   hdr.header.size = htons (s);
   hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ATS);
   if (force_rebuild)
@@ -574,7 +570,7 @@ send_dummy_data_task (void *cls, size_t size, void *buf)
   else if (force_q_updates)
     hdr.num = htonl (2);
   else
-    hdr.num = htonl (0); 
+    hdr.num = htonl (0);
   memcpy (buf, &hdr, s);
   // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i of %i\n", s, s);
   t = NULL;
@@ -582,30 +578,29 @@ send_dummy_data_task (void *cls, size_t size, void *buf)
 }
 
 
-static void 
-send_task_f (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+send_task_f (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   send_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
-  
-  if (t!=NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
+
+  if (t != NULL)
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
+    t = NULL;
+  }
 
   if (send_msg == GNUNET_YES)
-    t = GNUNET_TRANSPORT_notify_transmit_ready(th, 
-                                               &master_deamon->id, 
-                                               sizeof (struct TestMessage), 0, 
-                                               SEND_TIMEOUT, 
-                                               &send_dummy_data_task, NULL);
-  send_task = GNUNET_SCHEDULER_add_delayed(
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,1000),
-      &send_task_f,
-      NULL);
+    t = GNUNET_TRANSPORT_notify_transmit_ready (th,
+                                                &master_deamon->id,
+                                                sizeof (struct TestMessage), 0,
+                                                SEND_TIMEOUT,
+                                                &send_dummy_data_task, NULL);
+  send_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MILLISECONDS, 1000),
+                                    &send_task_f, NULL);
 
 }
 
@@ -615,135 +610,127 @@ notify_connect (void *cls,
                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
                 uint32_t ats_count)
 {
-  send_task = GNUNET_SCHEDULER_add_now(&send_task_f, NULL);
+  send_task = GNUNET_SCHEDULER_add_now (&send_task_f, NULL);
 }
 
 static void
-notify_disconnect (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   if (GNUNET_SCHEDULER_NO_TASK != send_task)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Disconnect event before transmission request could be scheduled!\n");
-      GNUNET_SCHEDULER_cancel (send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnect event before transmission request could be scheduled!\n");
+    GNUNET_SCHEDULER_cancel (send_task);
+    send_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != t)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Disconnect event before transmission request could be completed!\n");
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
-      t = NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnect event before transmission request could be completed!\n");
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
+    t = NULL;
+  }
 }
 
-static void 
-daemon_connect_cb(void *cls,
-                  const struct GNUNET_PeerIdentity *first,
-                  const struct GNUNET_PeerIdentity *second,
-                  uint32_t distance,
-                  const struct GNUNET_CONFIGURATION_Handle *first_cfg,
-                  const struct GNUNET_CONFIGURATION_Handle *second_cfg,
-                  struct GNUNET_TESTING_Daemon *first_daemon,
-                  struct GNUNET_TESTING_Daemon *second_daemon,
-                  const char *emsg)
+static void
+daemon_connect_cb (void *cls,
+                   const struct GNUNET_PeerIdentity *first,
+                   const struct GNUNET_PeerIdentity *second,
+                   uint32_t distance,
+                   const struct GNUNET_CONFIGURATION_Handle *first_cfg,
+                   const struct GNUNET_CONFIGURATION_Handle *second_cfg,
+                   struct GNUNET_TESTING_Daemon *first_daemon,
+                   struct GNUNET_TESTING_Daemon *second_daemon,
+                   const char *emsg)
 {
-  char * firstc =  strdup(GNUNET_i2s(first));
-  char * secondc =  strdup(GNUNET_i2s(second));
+  char *firstc = strdup (GNUNET_i2s (first));
+  char *secondc = strdup (GNUNET_i2s (second));
+
   connected++;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connected peers `%s'<->`%s' (%i/%i)\n", 
-              firstc, secondc, connected, peers-1);
-  GNUNET_free(firstc);
-  GNUNET_free(secondc);
-  
-  if ( ( (first_daemon == ping_deamon) || 
-         (second_daemon == ping_deamon) ) && 
-       (master_deamon != NULL) && 
-       (ping_deamon != NULL) )
-    {
-      th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,
-                                     &ping_deamon->id, 
-                                     NULL, NULL,
-                                     &notify_connect, 
-                                     &notify_disconnect);
-      force_q_updates = GNUNET_YES;
-      send_msg = GNUNET_YES;
-    }
+              "Connected peers `%s'<->`%s' (%i/%i)\n",
+              firstc, secondc, connected, peers - 1);
+  GNUNET_free (firstc);
+  GNUNET_free (secondc);
+
+  if (((first_daemon == ping_deamon) ||
+       (second_daemon == ping_deamon)) &&
+      (master_deamon != NULL) && (ping_deamon != NULL))
+  {
+    th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,
+                                   &ping_deamon->id,
+                                   NULL, NULL,
+                                   &notify_connect, &notify_disconnect);
+    force_q_updates = GNUNET_YES;
+    send_msg = GNUNET_YES;
+  }
 }
 
 
 
 static void
 daemon_start_cb (void *cls,
-                 const struct GNUNET_PeerIdentity *id,
-                 const struct GNUNET_CONFIGURATION_Handle *cfg,
-                 struct GNUNET_TESTING_Daemon *d, const char *emsg)
+                 const struct GNUNET_PeerIdentity *id,
+                 const struct GNUNET_CONFIGURATION_Handle *cfg,
+                 struct GNUNET_TESTING_Daemon *d, const char *emsg)
 {
   if (id == NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Start callback called with error (too long starting peers), aborting test!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error from testing: `%s'\n");
+    failed_peers++;
+    if (failed_peers == peers_left)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Start callback called with error (too long starting peers), aborting test!\n");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Error from testing: `%s'\n");
-      failed_peers++;
-      if (failed_peers == peers_left)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Too many peers failed, ending test!\n");
-          ok = 1;
-        shutdown_peers ();
-        }
-      return;
+                  "Too many peers failed, ending test!\n");
+      ok = 1;
+      shutdown_peers ();
     }
+    return;
+  }
   peers_left--;
 
   if (master_deamon == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Master peer `%s' '%s'\n",
-                  GNUNET_i2s(id), d->cfgfile);      
-      master_deamon = d;
-      stats = GNUNET_STATISTICS_create("transport", master_deamon->cfg);
-      GNUNET_assert (stats != NULL);
-      stats_task = GNUNET_SCHEDULER_add_now(&stats_get_task, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Master peer `%s' '%s'\n", GNUNET_i2s (id), d->cfgfile);
+    master_deamon = d;
+    stats = GNUNET_STATISTICS_create ("transport", master_deamon->cfg);
+    GNUNET_assert (stats != NULL);
+    stats_task = GNUNET_SCHEDULER_add_now (&stats_get_task, NULL);
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Connecting peer `%s'\n", 
-                  GNUNET_i2s(id), GNUNET_i2s(&master_deamon->id));
-      GNUNET_TESTING_daemons_connect(d,
-          master_deamon,
-          TIMEOUT,
-          0,
-          GNUNET_YES,
-          &daemon_connect_cb,
-          NULL);
-    }
-  
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connecting peer `%s'\n",
+                GNUNET_i2s (id), GNUNET_i2s (&master_deamon->id));
+    GNUNET_TESTING_daemons_connect (d,
+                                    master_deamon,
+                                    TIMEOUT,
+                                    0, GNUNET_YES, &daemon_connect_cb, NULL);
+  }
+
   if (peers_left == 0)
+  {
+    if (ping_deamon == NULL)
     {
-      if (ping_deamon == NULL)
-        {
-          ping_deamon = d;
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                      "Ping peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
-        }
-      
+      ping_deamon = d;
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers started successfully!\n");
-      connect_peers();
-      ok = 0;
+                  "Ping peer `%s' '%s'\n", GNUNET_i2s (id), d->cfgfile);
     }
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers started successfully!\n");
+    connect_peers ();
+    ok = 0;
+  }
   else if (failed_peers == peers_left)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Too many peers failed, ending test!\n");
-      shutdown_peers();
-      ok = 1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Too many peers failed, ending test!\n");
+    shutdown_peers ();
+    ok = 1;
+  }
 }
 
 
@@ -758,10 +745,9 @@ run (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting %i peers.\n", peers);
 #endif
   peers_left = peers;
-  pg = GNUNET_TESTING_daemons_start (cfg,
-                                     peers_left, /* Total number of peers */
-                                     peers_left, /* Number of outstanding connections */
-                                     peers_left, /* Number of parallel ssh connections, or peers being started at once */
+  pg = GNUNET_TESTING_daemons_start (cfg, peers_left,   /* Total number of peers */
+                                     peers_left,        /* Number of outstanding connections */
+                                     peers_left,        /* Number of parallel ssh connections, or peers being started at once */
                                      TIMEOUT,
                                      NULL, NULL,
                                      &daemon_start_cb, NULL, NULL, NULL, NULL);
@@ -808,28 +794,29 @@ main (int argc, char *argv[])
   config_file = "test_transport_ats_4addr.conf";
 
   int c = 0;
+
   if (argc >= 2)
-    {
-      for (c=0; c<argc; c++)
-        {
-          /* set peers */
-          if ((strcmp(argv[c], "-p") == 0) && c < (argc-1))
-            {
-              peers = atoi(argv[c+1]);
-              peers++;
-            }
-          /* set machine parsable */
-          if (strcmp(argv[c], "-m") == 0)
-            {
-              machine_parsable = GNUNET_YES;
-            }
-          /* set config file */
-          if ((strcmp(argv[c], "-c") == 0) && c < (argc-1))
-            {
-              config_file = argv[c+1];
-            }
-         }
-    }
+  {
+    for (c = 0; c < argc; c++)
+    {
+      /* set peers */
+      if ((strcmp (argv[c], "-p") == 0) && c < (argc - 1))
+      {
+        peers = atoi (argv[c + 1]);
+        peers++;
+      }
+      /* set machine parsable */
+      if (strcmp (argv[c], "-m") == 0)
+      {
+        machine_parsable = GNUNET_YES;
+      }
+      /* set config file */
+      if ((strcmp (argv[c], "-c") == 0) && c < (argc - 1))
+      {
+        config_file = argv[c + 1];
+      }
+    }
+  }
 
   ret = check ();
   /**
diff --git a/src/transport/test_transport_testing.c b/src/transport/test_transport_testing.c
index 514dd2b6e..cd5d7ed2c 100644
--- a/src/transport/test_transport_testing.c
+++ b/src/transport/test_transport_testing.c
@@ -50,8 +50,8 @@
 
 GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 
-static struct PeerContext * p1;
-static struct PeerContext * p2;
+static struct PeerContext *p1;
+static struct PeerContext *p2;
 
 static int connected = GNUNET_NO;
 
@@ -63,10 +63,10 @@ end ()
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
 
   if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(timeout_task);
+    GNUNET_SCHEDULER_cancel (timeout_task);
 
-  GNUNET_TRANSPORT_TESTING_stop_peer(p1);
-  GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p1);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 }
 
 static void
@@ -75,21 +75,21 @@ end_badly ()
   timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
 
-  GNUNET_TRANSPORT_TESTING_stop_peer(p1);
-  GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p1);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 
   ret = GNUNET_SYSERR;
 }
 
 static void
-testing_connect_cb (struct PeerContext * p1, struct PeerContext * p2, void *cls)
+testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
 {
-  char * p1_c = strdup (GNUNET_i2s(&p1->id));
+  char *p1_c = strdup (GNUNET_i2s (&p1->id));
+
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers connected: %s <-> %s\n",
-       p1_c,
-       GNUNET_i2s (&p2->id));
-  GNUNET_free(p1_c);
-  end();
+              p1_c, GNUNET_i2s (&p2->id));
+  GNUNET_free (p1_c);
+  end ();
 }
 
 static void
@@ -99,7 +99,7 @@ notify_connect (void *cls,
                 uint32_t ats_count)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%s' connected \n",
-       GNUNET_i2s (peer));
+              GNUNET_i2s (peer));
   connected++;
 }
 
@@ -107,7 +107,7 @@ static void
 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%s' disconnected \n",
-       GNUNET_i2s (peer));
+              GNUNET_i2s (peer));
 }
 
 static void
@@ -126,38 +126,39 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  timeout_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, &end_badly, NULL);
+  timeout_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &end_badly, NULL);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting peer\n");
-  p1 = GNUNET_TRANSPORT_TESTING_start_peer("test_transport_api_tcp_peer1.conf",
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      p1);
-
-  p2 = GNUNET_TRANSPORT_TESTING_start_peer("test_transport_api_tcp_peer2.conf",
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      p2);
+  p1 = GNUNET_TRANSPORT_TESTING_start_peer ("test_transport_api_tcp_peer1.conf",
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, p1);
+
+  p2 = GNUNET_TRANSPORT_TESTING_start_peer ("test_transport_api_tcp_peer2.conf",
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, p2);
 
   if (p1 != NULL)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer1 was successfully started\n");
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer1 was not started successfully\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer1 was not started successfully\n");
   GNUNET_assert (p1 != NULL);
   GNUNET_assert (p1->th != NULL);
 
   if (p2 != NULL)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer2 was successfully started\n");
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer2 was not started successfully\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer2 was not started successfully\n");
   GNUNET_assert (p2 != NULL);
   GNUNET_assert (p2->th != NULL);
 
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting peers\n");
-  GNUNET_TRANSPORT_TESTING_connect_peers(p1, p2, &testing_connect_cb, NULL);
+  GNUNET_TRANSPORT_TESTING_connect_peers (p1, p2, &testing_connect_cb, NULL);
 }
 
 int
diff --git a/src/transport/transport-testing.c b/src/transport/transport-testing.c
index 01419ce44..e6fcabb48 100644
--- a/src/transport/transport-testing.c
+++ b/src/transport/transport-testing.c
@@ -29,11 +29,11 @@
 
 struct ConnectingContext
 {
-  struct PeerContext * p1;
-  struct PeerContext * p2;
+  struct PeerContext *p1;
+  struct PeerContext *p2;
   GNUNET_SCHEDULER_TaskIdentifier tct;
   GNUNET_TRANSPORT_TESTING_connect_cb cb;
-  void * cb_cls;
+  void *cb_cls;
 
   struct GNUNET_TRANSPORT_Handle *th_p1;
   struct GNUNET_TRANSPORT_Handle *th_p2;
@@ -42,41 +42,43 @@ struct ConnectingContext
 };
 
 static void
-exchange_hello_last (void *cb_cls,
-                     const struct GNUNET_MessageHeader *message);
+exchange_hello_last (void *cb_cls, const struct GNUNET_MessageHeader *message);
 static void
-exchange_hello (void *cb_cls,
-                     const struct GNUNET_MessageHeader *message);
+exchange_hello (void *cb_cls, const struct GNUNET_MessageHeader *message);
 
 static void
 notify_connect_internal (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                uint32_t ats_count)
+                         const struct GNUNET_PeerIdentity *peer,
+                         const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                         uint32_t ats_count)
 {
-  struct ConnectingContext * cc = cls;
+  struct ConnectingContext *cc = cls;
 
-  GNUNET_assert(cc != NULL);
+  GNUNET_assert (cc != NULL);
 
-  if (0 == memcmp (&(*peer).hashPubKey, &cc->p1->id.hashPubKey, sizeof (GNUNET_HashCode)))
-    {
+  if (0 ==
+      memcmp (&(*peer).hashPubKey, &cc->p1->id.hashPubKey,
+              sizeof (GNUNET_HashCode)))
+  {
     if (cc->p1_c == GNUNET_NO)
       cc->p1_c = GNUNET_YES;
-    }
-  if (0 == memcmp (&(*peer).hashPubKey, &cc->p2->id.hashPubKey, sizeof (GNUNET_HashCode)))
-    {
+  }
+  if (0 ==
+      memcmp (&(*peer).hashPubKey, &cc->p2->id.hashPubKey,
+              sizeof (GNUNET_HashCode)))
+  {
     if (cc->p2_c == GNUNET_NO)
       cc->p2_c = GNUNET_YES;
-    }
+  }
 
   if ((cc->p2_c == GNUNET_YES) && (cc->p2_c == GNUNET_YES))
   {
-     /* clean up */
+    /* clean up */
     GNUNET_TRANSPORT_get_hello_cancel (cc->th_p2, &exchange_hello_last, cc);
     GNUNET_TRANSPORT_get_hello_cancel (cc->th_p1, &exchange_hello, cc);
 
     if (cc->tct != GNUNET_SCHEDULER_NO_TASK)
-      GNUNET_SCHEDULER_cancel(cc->tct);
+      GNUNET_SCHEDULER_cancel (cc->tct);
 
     cc->tct = GNUNET_SCHEDULER_NO_TASK;
 
@@ -86,7 +88,7 @@ notify_connect_internal (void *cls,
     if (cc->cb != NULL)
       cc->cb (cc->p1, cc->p2, cc->cb_cls);
 
-    GNUNET_free(cc);
+    GNUNET_free (cc);
   }
 }
 
@@ -96,7 +98,8 @@ notify_connect (void *cls,
                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
                 uint32_t ats_count)
 {
-  struct PeerContext * p = cls;
+  struct PeerContext *p = cls;
+
   if (p == NULL)
     return;
   if (p->nc != NULL)
@@ -106,7 +109,8 @@ notify_connect (void *cls,
 static void
 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
-  struct PeerContext * p = cls;
+  struct PeerContext *p = cls;
+
   if (p == NULL)
     return;
   if (p->nd != NULL)
@@ -120,7 +124,8 @@ notify_receive (void *cls,
                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
                 uint32_t ats_count)
 {
-  struct PeerContext * p = cls;
+  struct PeerContext *p = cls;
+
   if (p == NULL)
     return;
   if (p->rec != NULL)
@@ -129,18 +134,18 @@ notify_receive (void *cls,
 
 
 static void
-exchange_hello_last (void *cb_cls,
-                     const struct GNUNET_MessageHeader *message)
+exchange_hello_last (void *cb_cls, const struct GNUNET_MessageHeader *message)
 {
-  struct ConnectingContext * cc = cb_cls;
+  struct ConnectingContext *cc = cb_cls;
   struct PeerContext *me = cc->p2;
+
   //struct PeerContext *p1 = cc->p1;
 
   GNUNET_assert (message != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Exchanging HELLO of size %d with peer (%s)!\n",
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
@@ -149,11 +154,11 @@ exchange_hello_last (void *cb_cls,
 
 
 static void
-exchange_hello (void *cb_cls,
-                const struct GNUNET_MessageHeader *message)
+exchange_hello (void *cb_cls, const struct GNUNET_MessageHeader *message)
 {
-  struct ConnectingContext * cc = cb_cls;
+  struct ConnectingContext *cc = cb_cls;
   struct PeerContext *me = cc->p1;
+
   //struct PeerContext *p2 = cc->p2;
 
   GNUNET_assert (message != NULL);
@@ -162,34 +167,29 @@ exchange_hello (void *cb_cls,
                                       message, &me->id));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Exchanging HELLO of size %d from peer %s!\n",
-              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
-              GNUNET_i2s (&me->id));
+              (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
+                                       message), GNUNET_i2s (&me->id));
   GNUNET_TRANSPORT_offer_hello (cc->th_p2, message, NULL, NULL);
 }
 
 static void
-try_connect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct ConnectingContext * cc = cls;
+  struct ConnectingContext *cc = cls;
   struct PeerContext *p1 = cc->p1;
   struct PeerContext *p2 = cc->p2;
 
   cc->tct = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking peers to connect...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking peers to connect...\n");
   /* FIXME: 'pX.id' may still be all-zeros here... */
-  GNUNET_TRANSPORT_try_connect (cc->th_p1,
-                                &p2->id);
-  GNUNET_TRANSPORT_try_connect (cc->th_p2,
-                                &p1->id);
+  GNUNET_TRANSPORT_try_connect (cc->th_p1, &p2->id);
+  GNUNET_TRANSPORT_try_connect (cc->th_p2, &p1->id);
 
   cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                      &try_connect,
-                                      cc);
+                                          &try_connect, cc);
 }
 
 
@@ -202,30 +202,30 @@ try_connect (void *cls,
  * @return the peer context
  */
 struct PeerContext *
-GNUNET_TRANSPORT_TESTING_start_peer (const char * cfgname,
-    GNUNET_TRANSPORT_ReceiveCallback rec,
-    GNUNET_TRANSPORT_NotifyConnect nc,
-    GNUNET_TRANSPORT_NotifyDisconnect nd,
-    void * cb_cls)
+GNUNET_TRANSPORT_TESTING_start_peer (const char *cfgname,
+                                     GNUNET_TRANSPORT_ReceiveCallback rec,
+                                     GNUNET_TRANSPORT_NotifyConnect nc,
+                                     GNUNET_TRANSPORT_NotifyDisconnect nd,
+                                     void *cb_cls)
 {
-  struct PeerContext * p = GNUNET_malloc (sizeof (struct PeerContext));
+  struct PeerContext *p = GNUNET_malloc (sizeof (struct PeerContext));
 
   p->cfg = GNUNET_CONFIGURATION_create ();
 
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome);
+  if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME",
+                                           &p->servicehome);
   if (NULL != p->servicehome)
     GNUNET_DISK_directory_remove (p->servicehome);
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
-                                        "-c", cfgname,
+                                         "gnunet-service-arm", "-c", cfgname,
 #if VERBOSE_PEERS
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #else
-                                        "-L", "ERROR",
+                                         "-L", "ERROR",
 #endif
-                                        NULL);
+                                         NULL);
   p->nc = nc;
   p->nd = nd;
   p->rec = rec;
@@ -234,11 +234,10 @@ GNUNET_TRANSPORT_TESTING_start_peer (const char * cfgname,
   else
     p->cb_cls = p;
 
-  p->th = GNUNET_TRANSPORT_connect(p->cfg, NULL,
-                            p,
-                            &notify_receive,
-                            &notify_connect,
-                            &notify_disconnect);
+  p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
+                                    p,
+                                    &notify_receive,
+                                    &notify_connect, &notify_disconnect);
   GNUNET_assert (p->th != NULL);
   return p;
 }
@@ -248,25 +247,25 @@ GNUNET_TRANSPORT_TESTING_start_peer (const char * cfgname,
  * @param p the peer
  */
 void
-GNUNET_TRANSPORT_TESTING_stop_peer (struct PeerContext * p)
+GNUNET_TRANSPORT_TESTING_stop_peer (struct PeerContext *p)
 {
   if (p->th != NULL)
-    GNUNET_TRANSPORT_disconnect(p->th);
+    GNUNET_TRANSPORT_disconnect (p->th);
 
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      GNUNET_OS_process_wait (p->arm_proc);
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    GNUNET_OS_process_wait (p->arm_proc);
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
   GNUNET_CONFIGURATION_destroy (p->cfg);
   if (p->servicehome != NULL)
-    {
+  {
     GNUNET_DISK_directory_remove (p->servicehome);
-    GNUNET_free(p->servicehome);
-    }
+    GNUNET_free (p->servicehome);
+  }
   GNUNET_free (p);
 }
 
@@ -280,12 +279,13 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct PeerContext * p)
  * @param cb_cls callback cls
  */
 void
-GNUNET_TRANSPORT_TESTING_connect_peers (struct PeerContext * p1,
-                                        struct PeerContext * p2,
+GNUNET_TRANSPORT_TESTING_connect_peers (struct PeerContext *p1,
+                                        struct PeerContext *p2,
                                         GNUNET_TRANSPORT_TESTING_connect_cb cb,
-                                        void * cb_cls)
+                                        void *cb_cls)
 {
-  struct ConnectingContext * cc = GNUNET_malloc (sizeof (struct ConnectingContext));
+  struct ConnectingContext *cc =
+      GNUNET_malloc (sizeof (struct ConnectingContext));
 
   GNUNET_assert (p1 != NULL);
   GNUNET_assert (p2 != NULL);
@@ -296,17 +296,13 @@ GNUNET_TRANSPORT_TESTING_connect_peers (struct PeerContext * p1,
   cc->cb = cb;
   cc->cb_cls = cb_cls;
 
-  cc->th_p1 = GNUNET_TRANSPORT_connect(cc->p1->cfg, NULL,
-                            cc,
-                            NULL,
-                            &notify_connect_internal,
-                            NULL);
-
-  cc->th_p2 = GNUNET_TRANSPORT_connect(cc->p2->cfg, NULL,
-                            cc,
-                            NULL,
-                            &notify_connect_internal,
-                            NULL);
+  cc->th_p1 = GNUNET_TRANSPORT_connect (cc->p1->cfg, NULL,
+                                        cc,
+                                        NULL, &notify_connect_internal, NULL);
+
+  cc->th_p2 = GNUNET_TRANSPORT_connect (cc->p2->cfg, NULL,
+                                        cc,
+                                        NULL, &notify_connect_internal, NULL);
 
   GNUNET_assert (cc->th_p1 != NULL);
   GNUNET_assert (cc->th_p2 != NULL);
diff --git a/src/transport/transport-testing.h b/src/transport/transport-testing.h
index 10ef030f4..a867df4c1 100644
--- a/src/transport/transport-testing.h
+++ b/src/transport/transport-testing.h
@@ -53,16 +53,18 @@ struct PeerContext
 
   GNUNET_TRANSPORT_NotifyDisconnect nd;
 
-  void * cb_cls;
+  void *cb_cls;
 
-  char * servicehome;
+  char *servicehome;
 };
 
 /**
  * Callback when two peers are connected and both have called the connect callback
  * to notify clients about a new peer
  */
-typedef void (*GNUNET_TRANSPORT_TESTING_connect_cb) (struct PeerContext * p1, struct PeerContext * p2, void *cls);
+typedef void (*GNUNET_TRANSPORT_TESTING_connect_cb) (struct PeerContext * p1,
+                                                     struct PeerContext * p2,
+                                                     void *cls);
 
 
 /**
@@ -74,12 +76,13 @@ typedef void (*GNUNET_TRANSPORT_TESTING_connect_cb) (struct PeerContext * p1, st
  *   if NULL passed the PeerContext * will be used!
  * @return the peer context
  */
-struct PeerContext *
-GNUNET_TRANSPORT_TESTING_start_peer (const char * cfgname,
-    GNUNET_TRANSPORT_ReceiveCallback rec,
-    GNUNET_TRANSPORT_NotifyConnect nc,
-    GNUNET_TRANSPORT_NotifyDisconnect nd,
-    void * cb_cls);
+struct PeerContext *GNUNET_TRANSPORT_TESTING_start_peer (const char *cfgname,
+                                                         GNUNET_TRANSPORT_ReceiveCallback
+                                                         rec,
+                                                         GNUNET_TRANSPORT_NotifyConnect
+                                                         nc,
+                                                         GNUNET_TRANSPORT_NotifyDisconnect
+                                                         nd, void *cb_cls);
 
 
 /**
@@ -87,8 +90,7 @@ GNUNET_TRANSPORT_TESTING_start_peer (const char * cfgname,
  * @param p the peer
  */
 
-void
-GNUNET_TRANSPORT_TESTING_stop_peer (struct PeerContext * pc);
+void GNUNET_TRANSPORT_TESTING_stop_peer (struct PeerContext *pc);
 
 
 /**
@@ -101,9 +103,9 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct PeerContext * pc);
  * @param cb_cls callback cls
  */
 void
-GNUNET_TRANSPORT_TESTING_connect_peers (struct PeerContext * p1,
-    struct PeerContext * p2,
-    GNUNET_TRANSPORT_TESTING_connect_cb cb,
-    void * cls);
+GNUNET_TRANSPORT_TESTING_connect_peers (struct PeerContext *p1,
+                                        struct PeerContext *p2,
+                                        GNUNET_TRANSPORT_TESTING_connect_cb cb,
+                                        void *cls);
 
 /* end of transport_testing.h */
diff --git a/src/transport/transport.h b/src/transport/transport.h
index 4d1d370d9..a694d86e5 100644
--- a/src/transport/transport.h
+++ b/src/transport/transport.h
@@ -319,7 +319,7 @@ struct AddressLookupMessage
   uint32_t addrlen GNUNET_PACKED;
 
   /* followed by 'addrlen' bytes of the actual address, then
-     followed by the 0-terminated name of the transport */
+   * followed by the 0-terminated name of the transport */
 };
 
 
diff --git a/src/transport/transport_api.c b/src/transport/transport_api.c
index 4583cf876..2cdaacad6 100644
--- a/src/transport/transport_api.c
+++ b/src/transport/transport_api.c
@@ -255,7 +255,7 @@ struct GNUNET_TRANSPORT_Handle
    * specify when we could next send a message to the respective peer.
    * Excludes control messages (which can always go out immediately).
    * Maps time stamps to 'struct Neighbour' entries.
-   */ 
+   */
   struct GNUNET_CONTAINER_Heap *ready_heap;
 
   /**
@@ -295,8 +295,7 @@ struct GNUNET_TRANSPORT_Handle
  *
  * @param h transport service to schedule a transmission for
  */
-static void
-schedule_transmission (struct GNUNET_TRANSPORT_Handle *h);
+static void schedule_transmission (struct GNUNET_TRANSPORT_Handle *h);
 
 
 /**
@@ -320,7 +319,7 @@ static struct Neighbour *
 neighbour_find (struct GNUNET_TRANSPORT_Handle *h,
                 const struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CONTAINER_multihashmap_get(h->neighbours, &peer->hashPubKey);
+  return GNUNET_CONTAINER_multihashmap_get (h->neighbours, &peer->hashPubKey);
 }
 
 
@@ -337,21 +336,20 @@ neighbour_add (struct GNUNET_TRANSPORT_Handle *h,
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Creating entry for neighbour `%4s'.\n",
-              GNUNET_i2s (pid));
+              "Creating entry for neighbour `%4s'.\n", GNUNET_i2s (pid));
 #endif
   n = GNUNET_malloc (sizeof (struct Neighbour));
   n->id = *pid;
   n->h = h;
   n->is_ready = GNUNET_YES;
   GNUNET_BANDWIDTH_tracker_init (&n->out_tracker,
-                                 GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
-                                 MAX_BANDWIDTH_CARRY_S);
+                                 GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
+                                 MAX_BANDWIDTH_CARRY_S);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (h->neighbours,
-                                                    &pid->hashPubKey,
-                                                    n,
-                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                 GNUNET_CONTAINER_multihashmap_put (h->neighbours,
+                                                    &pid->hashPubKey,
+                                                    n,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return n;
 }
 
@@ -367,22 +365,18 @@ neighbour_add (struct GNUNET_TRANSPORT_Handle *h,
  *         GNUNET_NO if not.
  */
 static int
-neighbour_delete (void *cls,
-                  const GNUNET_HashCode * key,
-                  void *value)
+neighbour_delete (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_TRANSPORT_Handle *handle = cls;
   struct Neighbour *n = value;
 
   if (NULL != handle->nd_cb)
-    handle->nd_cb (handle->cls,
-                   &n->id);
+    handle->nd_cb (handle->cls, &n->id);
   GNUNET_assert (NULL == n->th);
   GNUNET_assert (NULL == n->hn);
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (handle->neighbours,
-                                                       key,
-                                                       n));
+                 GNUNET_CONTAINER_multihashmap_remove (handle->neighbours,
+                                                       key, n));
   GNUNET_free (n);
   return GNUNET_YES;
 }
@@ -395,8 +389,7 @@ neighbour_delete (void *cls,
  * @param msg message received, NULL on timeout or fatal error
  */
 static void
-demultiplexer (void *cls,
-               const struct GNUNET_MessageHeader *msg)
+demultiplexer (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_TRANSPORT_Handle *h = cls;
   const struct DisconnectInfoMessage *dim;
@@ -413,177 +406,171 @@ demultiplexer (void *cls,
 
   GNUNET_assert (h->client != NULL);
   if (msg == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "Error receiving from transport service, disconnecting temporarily.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Error receiving from transport service, disconnecting temporarily.\n");
 #endif
-      disconnect_and_schedule_reconnect (h);
-      return;
-    }
+    disconnect_and_schedule_reconnect (h);
+    return;
+  }
   GNUNET_CLIENT_receive (h->client,
-                         &demultiplexer, h, 
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &demultiplexer, h, GNUNET_TIME_UNIT_FOREVER_REL);
   size = ntohs (msg->size);
   switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_HELLO:
+    if (GNUNET_OK !=
+        GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) msg, &me))
     {
-    case GNUNET_MESSAGE_TYPE_HELLO:
-      if (GNUNET_OK !=
-          GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) msg,
-                               &me))
-        {
-          GNUNET_break (0);
-          break;
-        }
+      GNUNET_break (0);
+      break;
+    }
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receiving (my own) `%s' message, I am `%4s'.\n",
-                  "HELLO", GNUNET_i2s (&me));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receiving (my own) `%s' message, I am `%4s'.\n",
+                "HELLO", GNUNET_i2s (&me));
 #endif
-      GNUNET_free_non_null (h->my_hello);
-      h->my_hello = NULL;
-      if (size < sizeof (struct GNUNET_MessageHeader))
-        {
-          GNUNET_break (0);
-          break;
-        }
-      h->my_hello = GNUNET_malloc (size);
-      memcpy (h->my_hello, msg, size);
-      hwl = h->hwl_head;
-      while (NULL != hwl)
-        {
-          next_hwl = hwl->next;
-          hwl->rec (hwl->rec_cls,
-                    (const struct GNUNET_MessageHeader *) h->my_hello);
-          hwl = next_hwl;
-        }
+    GNUNET_free_non_null (h->my_hello);
+    h->my_hello = NULL;
+    if (size < sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    h->my_hello = GNUNET_malloc (size);
+    memcpy (h->my_hello, msg, size);
+    hwl = h->hwl_head;
+    while (NULL != hwl)
+    {
+      next_hwl = hwl->next;
+      hwl->rec (hwl->rec_cls,
+                (const struct GNUNET_MessageHeader *) h->my_hello);
+      hwl = next_hwl;
+    }
+    break;
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT:
+    if (size < sizeof (struct ConnectInfoMessage))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    cim = (const struct ConnectInfoMessage *) msg;
+    ats_count = ntohl (cim->ats_count);
+    if (size !=
+        sizeof (struct ConnectInfoMessage) +
+        ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information))
+    {
+      GNUNET_break (0);
       break;
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT:
-      if (size < sizeof (struct ConnectInfoMessage))
-        {
-          GNUNET_break (0);
-          break;
-        }
-      cim = (const struct ConnectInfoMessage *) msg;
-      ats_count = ntohl (cim->ats_count);
-      if (size != sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information))
-        {
-          GNUNET_break (0);
-          break;
-        }
+    }
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receiving `%s' message for `%4s'.\n",
-                  "CONNECT", GNUNET_i2s (&cim->id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receiving `%s' message for `%4s'.\n",
+                "CONNECT", GNUNET_i2s (&cim->id));
 #endif
-      n = neighbour_find (h, &cim->id);
-      if (n != NULL)
-        {
-          GNUNET_break (0);
-          break;
-        }
-      n = neighbour_add (h, &cim->id);
-      if (h->nc_cb != NULL)
-        h->nc_cb (h->cls, &n->id,
-                  &cim->ats, ats_count);
+    n = neighbour_find (h, &cim->id);
+    if (n != NULL)
+    {
+      GNUNET_break (0);
+      break;
+    }
+    n = neighbour_add (h, &cim->id);
+    if (h->nc_cb != NULL)
+      h->nc_cb (h->cls, &n->id, &cim->ats, ats_count);
+    break;
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT:
+    if (size != sizeof (struct DisconnectInfoMessage))
+    {
+      GNUNET_break (0);
       break;
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT:
-      if (size != sizeof (struct DisconnectInfoMessage))
-        {
-          GNUNET_break (0);
-          break;
-        }
-      dim = (const struct DisconnectInfoMessage *) msg;
-      GNUNET_break (ntohl (dim->reserved) == 0);
+    }
+    dim = (const struct DisconnectInfoMessage *) msg;
+    GNUNET_break (ntohl (dim->reserved) == 0);
 #if DEBUG_TRANSPORT_DISCONNECT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receiving `%s' message for `%4s'.\n",
-                  "DISCONNECT",
-                  GNUNET_i2s (&dim->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receiving `%s' message for `%4s'.\n",
+                "DISCONNECT", GNUNET_i2s (&dim->peer));
 #endif
-      n = neighbour_find (h, &dim->peer);
-      if (n == NULL)
-        {
-          GNUNET_break (0);
-          break;
-        }
-      neighbour_delete (h, &dim->peer.hashPubKey, n);
+    n = neighbour_find (h, &dim->peer);
+    if (n == NULL)
+    {
+      GNUNET_break (0);
+      break;
+    }
+    neighbour_delete (h, &dim->peer.hashPubKey, n);
+    break;
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK:
+    if (size != sizeof (struct SendOkMessage))
+    {
+      GNUNET_break (0);
       break;
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK:
-      if (size != sizeof (struct SendOkMessage))
-        {
-          GNUNET_break (0);
-          break;
-        }
-      okm = (const struct SendOkMessage *) msg;
+    }
+    okm = (const struct SendOkMessage *) msg;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receiving `%s' message, transmission %s.\n", "SEND_OK",
-                  ntohl (okm->success) == GNUNET_OK ? "succeeded" : "failed");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receiving `%s' message, transmission %s.\n", "SEND_OK",
+                ntohl (okm->success) == GNUNET_OK ? "succeeded" : "failed");
 #endif
-      n = neighbour_find (h, &okm->peer);
-      if (n == NULL)
-        break;  
-      GNUNET_break (GNUNET_NO == n->is_ready);
-      n->is_ready = GNUNET_YES;
-      if ( (n->th != NULL) &&
-           (n->hn == NULL) )
-        {
-          GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != n->th->timeout_task);
-          GNUNET_SCHEDULER_cancel (n->th->timeout_task);
-          n->th->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-          /* we've been waiting for this (congestion, not quota, 
-             caused delayed transmission) */
-          n->hn = GNUNET_CONTAINER_heap_insert (h->ready_heap,
-                                                n, 0);
-          schedule_transmission (h);
-        }
+    n = neighbour_find (h, &okm->peer);
+    if (n == NULL)
       break;
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_RECV:
+    GNUNET_break (GNUNET_NO == n->is_ready);
+    n->is_ready = GNUNET_YES;
+    if ((n->th != NULL) && (n->hn == NULL))
+    {
+      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != n->th->timeout_task);
+      GNUNET_SCHEDULER_cancel (n->th->timeout_task);
+      n->th->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+      /* we've been waiting for this (congestion, not quota, 
+       * caused delayed transmission) */
+      n->hn = GNUNET_CONTAINER_heap_insert (h->ready_heap, n, 0);
+      schedule_transmission (h);
+    }
+    break;
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_RECV:
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receiving `%s' message.\n", "RECV");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving `%s' message.\n", "RECV");
 #endif
-      if (size <
-          sizeof (struct InboundMessage) +
-          sizeof (struct GNUNET_MessageHeader))
-        {
-          GNUNET_break (0);
-          break;
-        }
-      im = (const struct InboundMessage *) msg;
-      GNUNET_break (0 == ntohl (im->reserved));
-      ats_count = ntohl(im->ats_count);
-      imm = (const struct GNUNET_MessageHeader *) &((&(im->ats))[ats_count+1]);
-
-      if (ntohs (imm->size) + sizeof (struct InboundMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) != size)
-        {
-          GNUNET_break (0);
-          break;
-        }
+    if (size <
+        sizeof (struct InboundMessage) + sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    im = (const struct InboundMessage *) msg;
+    GNUNET_break (0 == ntohl (im->reserved));
+    ats_count = ntohl (im->ats_count);
+    imm = (const struct GNUNET_MessageHeader *) &((&(im->ats))[ats_count + 1]);
+
+    if (ntohs (imm->size) + sizeof (struct InboundMessage) +
+        ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) != size)
+    {
+      GNUNET_break (0);
+      break;
+    }
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received message of type %u from `%4s'.\n",
-                  ntohs (imm->type), GNUNET_i2s (&im->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received message of type %u from `%4s'.\n",
+                ntohs (imm->type), GNUNET_i2s (&im->peer));
 #endif
-      n = neighbour_find (h, &im->peer);
-      if (n == NULL)
-        {
-          GNUNET_break (0);
-          break;
-        }
-      if (h->rec != NULL)
-        h->rec (h->cls, &im->peer, imm,
-                &im->ats, ats_count);
-      break;
-    default:
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Received unexpected message of type %u in %s:%u\n"),
-                  ntohs (msg->type), __FILE__, __LINE__);
+    n = neighbour_find (h, &im->peer);
+    if (n == NULL)
+    {
       GNUNET_break (0);
       break;
     }
+    if (h->rec != NULL)
+      h->rec (h->cls, &im->peer, imm, &im->ats, ats_count);
+    break;
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Received unexpected message of type %u in %s:%u\n"),
+                ntohs (msg->type), __FILE__, __LINE__);
+    GNUNET_break (0);
+    break;
+  }
 }
 
 
@@ -596,7 +583,8 @@ demultiplexer (void *cls,
  */
 static void
 timeout_request_due_to_congestion (void *cls,
-                                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+                                   const struct GNUNET_SCHEDULER_TaskContext
+                                   *tc)
 {
   struct GNUNET_TRANSPORT_TransmitHandle *th = cls;
   struct Neighbour *n = th->neighbour;
@@ -633,77 +621,78 @@ transport_notify_ready (void *cls, size_t size, void *buf)
   GNUNET_assert (NULL != h->client);
   h->cth = NULL;
   if (NULL == buf)
-    {
-      /* transmission failed */
-      disconnect_and_schedule_reconnect (h);
-      return 0;
-    }
+  {
+    /* transmission failed */
+    disconnect_and_schedule_reconnect (h);
+    return 0;
+  }
 
   cbuf = buf;
   ret = 0;
   /* first send control messages */
-  while ( (NULL != (th = h->control_head)) &&
-          (th->notify_size <= size) )
-    {
-      GNUNET_CONTAINER_DLL_remove (h->control_head,
-                                   h->control_tail,
-                                   th);
-      nret = th->notify (th->notify_cls, size, &cbuf[ret]);
+  while ((NULL != (th = h->control_head)) && (th->notify_size <= size))
+  {
+    GNUNET_CONTAINER_DLL_remove (h->control_head, h->control_tail, th);
+    nret = th->notify (th->notify_cls, size, &cbuf[ret]);
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Added %u bytes of control message at %u\n",
-                  nret,
-                  ret);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Added %u bytes of control message at %u\n", nret, ret);
 #endif
-      GNUNET_free (th);
-      ret += nret;
-      size -= nret;
-    }
+    GNUNET_free (th);
+    ret += nret;
+    size -= nret;
+  }
 
   /* then, if possible and no control messages pending, send data messages */
-  while ( (NULL == h->control_head) &&
-          (NULL != (n = GNUNET_CONTAINER_heap_peek (h->ready_heap))) )
+  while ((NULL == h->control_head) &&
+         (NULL != (n = GNUNET_CONTAINER_heap_peek (h->ready_heap))))
+  {
+    if (GNUNET_YES != n->is_ready)
     {
-       if (GNUNET_YES != n->is_ready)
-        {
-          /* peer not ready, wait for notification! */
-          GNUNET_assert (n == GNUNET_CONTAINER_heap_remove_root (h->ready_heap));
-          n->hn = NULL;
-          GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == n->th->timeout_task);
-          n->th->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining (n->th->timeout),
-                                                              &timeout_request_due_to_congestion,
-                                                              n->th);
-          continue;
-        }
-      th = n->th;
-      if (th->notify_size + sizeof (struct OutboundMessage) > size)
-        break; /* does not fit */
-      if (GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, th->notify_size).rel_value > 0)
-        break; /* too early */
+      /* peer not ready, wait for notification! */
       GNUNET_assert (n == GNUNET_CONTAINER_heap_remove_root (h->ready_heap));
       n->hn = NULL;
-      n->th = NULL;
-      n->is_ready = GNUNET_NO;
-      GNUNET_assert (size >= sizeof (struct OutboundMessage));
-      mret = th->notify (th->notify_cls,
-                         size - sizeof (struct OutboundMessage),
-                         &cbuf[ret + sizeof (struct OutboundMessage)]);
-      GNUNET_assert (mret <= size - sizeof (struct OutboundMessage));
-      if (mret != 0)    
-        {
-          GNUNET_assert (mret + sizeof (struct OutboundMessage) < GNUNET_SERVER_MAX_MESSAGE_SIZE);
-          obm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND);
-          obm.header.size = htons (mret + sizeof (struct OutboundMessage));
-          obm.priority = htonl (th->priority);
-          obm.timeout = GNUNET_TIME_relative_hton (GNUNET_TIME_absolute_get_remaining (th->timeout));
-          obm.peer = n->id;
-          memcpy (&cbuf[ret], &obm, sizeof (struct OutboundMessage));
-          ret += (mret + sizeof (struct OutboundMessage));
-          size -= (mret + sizeof (struct OutboundMessage));
-          GNUNET_BANDWIDTH_tracker_consume (&n->out_tracker, mret);
-        }
-      GNUNET_free (th);
+      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == n->th->timeout_task);
+      n->th->timeout_task =
+          GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
+                                        (n->th->timeout),
+                                        &timeout_request_due_to_congestion,
+                                        n->th);
+      continue;
+    }
+    th = n->th;
+    if (th->notify_size + sizeof (struct OutboundMessage) > size)
+      break;                    /* does not fit */
+    if (GNUNET_BANDWIDTH_tracker_get_delay
+        (&n->out_tracker, th->notify_size).rel_value > 0)
+      break;                    /* too early */
+    GNUNET_assert (n == GNUNET_CONTAINER_heap_remove_root (h->ready_heap));
+    n->hn = NULL;
+    n->th = NULL;
+    n->is_ready = GNUNET_NO;
+    GNUNET_assert (size >= sizeof (struct OutboundMessage));
+    mret = th->notify (th->notify_cls,
+                       size - sizeof (struct OutboundMessage),
+                       &cbuf[ret + sizeof (struct OutboundMessage)]);
+    GNUNET_assert (mret <= size - sizeof (struct OutboundMessage));
+    if (mret != 0)
+    {
+      GNUNET_assert (mret + sizeof (struct OutboundMessage) <
+                     GNUNET_SERVER_MAX_MESSAGE_SIZE);
+      obm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND);
+      obm.header.size = htons (mret + sizeof (struct OutboundMessage));
+      obm.priority = htonl (th->priority);
+      obm.timeout =
+          GNUNET_TIME_relative_hton (GNUNET_TIME_absolute_get_remaining
+                                     (th->timeout));
+      obm.peer = n->id;
+      memcpy (&cbuf[ret], &obm, sizeof (struct OutboundMessage));
+      ret += (mret + sizeof (struct OutboundMessage));
+      size -= (mret + sizeof (struct OutboundMessage));
+      GNUNET_BANDWIDTH_tracker_consume (&n->out_tracker, mret);
     }
+    GNUNET_free (th);
+  }
   /* if there are more pending messages, try to schedule those */
   schedule_transmission (h);
 #if DEBUG_TRANSPORT
@@ -723,7 +712,7 @@ transport_notify_ready (void *cls, size_t size, void *buf)
  */
 static void
 schedule_transmission_task (void *cls,
-                            const struct GNUNET_SCHEDULER_TaskContext *tc)
+                            const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TRANSPORT_Handle *h = cls;
   size_t size;
@@ -733,48 +722,45 @@ schedule_transmission_task (void *cls,
   h->quota_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_assert (NULL != h->client);
   /* destroy all requests that have timed out */
-  while ( (NULL != (n = GNUNET_CONTAINER_heap_peek (h->ready_heap))) &&
-          (GNUNET_TIME_absolute_get_remaining (n->th->timeout).rel_value == 0) )
-    {
-      /* notify client that the request could not be satisfied within
-         the given time constraints */
-      th = n->th;
-      n->th = NULL;
-      GNUNET_assert (n == GNUNET_CONTAINER_heap_remove_root (h->ready_heap));
-      n->hn = NULL;
+  while ((NULL != (n = GNUNET_CONTAINER_heap_peek (h->ready_heap))) &&
+         (GNUNET_TIME_absolute_get_remaining (n->th->timeout).rel_value == 0))
+  {
+    /* notify client that the request could not be satisfied within
+     * the given time constraints */
+    th = n->th;
+    n->th = NULL;
+    GNUNET_assert (n == GNUNET_CONTAINER_heap_remove_root (h->ready_heap));
+    n->hn = NULL;
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Signalling timeout for transmission to peer %s due to congestion\n",
-                  GNUNET_i2s (&n->id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Signalling timeout for transmission to peer %s due to congestion\n",
+                GNUNET_i2s (&n->id));
 #endif
-      GNUNET_assert (0 == 
-                     th->notify (th->notify_cls, 0, NULL));
-      GNUNET_free (th);      
-    }
+    GNUNET_assert (0 == th->notify (th->notify_cls, 0, NULL));
+    GNUNET_free (th);
+  }
   if (NULL != h->cth)
     return;
   if (NULL != h->control_head)
-    {
-      size = h->control_head->notify_size;
-    }
+  {
+    size = h->control_head->notify_size;
+  }
   else
-    {
-      n = GNUNET_CONTAINER_heap_peek (h->ready_heap);
-      if (NULL == n)
-        return; /* no pending messages */
-      size = n->th->notify_size + sizeof (struct OutboundMessage);
-    }  
+  {
+    n = GNUNET_CONTAINER_heap_peek (h->ready_heap);
+    if (NULL == n)
+      return;                   /* no pending messages */
+    size = n->th->notify_size + sizeof (struct OutboundMessage);
+  }
 #if DEBUG_TRANSPORT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Calling notify_transmit_ready\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Calling notify_transmit_ready\n");
 #endif
   h->cth =
-    GNUNET_CLIENT_notify_transmit_ready (h->client,
-                                         size,
-                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                         GNUNET_NO,
-                                         &transport_notify_ready,
-                                         h);
+      GNUNET_CLIENT_notify_transmit_ready (h->client,
+                                           size,
+                                           GNUNET_TIME_UNIT_FOREVER_REL,
+                                           GNUNET_NO,
+                                           &transport_notify_ready, h);
   GNUNET_assert (NULL != h->cth);
 }
 
@@ -793,22 +779,23 @@ schedule_transmission (struct GNUNET_TRANSPORT_Handle *h)
 
   GNUNET_assert (NULL != h->client);
   if (h->quota_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (h->quota_task);
-      h->quota_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->quota_task);
+    h->quota_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != h->control_head)
     delay = GNUNET_TIME_UNIT_ZERO;
-  else if (NULL != (n = GNUNET_CONTAINER_heap_peek (h->ready_heap)))    
-    delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, n->th->notify_size);
+  else if (NULL != (n = GNUNET_CONTAINER_heap_peek (h->ready_heap)))
+    delay =
+        GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker,
+                                            n->th->notify_size);
   else
-    return; /* no work to be done */
+    return;                     /* no work to be done */
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Scheduling next transmission to service in %llu ms\n",
-              (unsigned long long) delay.rel_value);
+              "Scheduling next transmission to service in %llu ms\n",
+              (unsigned long long) delay.rel_value);
   h->quota_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                &schedule_transmission_task,
-                                                h);
+                                                &schedule_transmission_task, h);
 }
 
 
@@ -831,16 +818,13 @@ schedule_control_transmit (struct GNUNET_TRANSPORT_Handle *h,
 
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Control transmit of %u bytes requested\n",
-              size);
+              "Control transmit of %u bytes requested\n", size);
 #endif
   th = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TransmitHandle));
   th->notify = notify;
   th->notify_cls = notify_cls;
   th->notify_size = size;
-  GNUNET_CONTAINER_DLL_insert_tail (h->control_head,
-                                    h->control_tail,
-                                    th);
+  GNUNET_CONTAINER_DLL_insert_tail (h->control_head, h->control_tail, th);
   schedule_transmission (h);
 }
 
@@ -860,18 +844,16 @@ send_start (void *cls, size_t size, void *buf)
   struct StartMessage s;
 
   if (buf == NULL)
-    {
-      /* Can only be shutdown, just give up */
+  {
+    /* Can only be shutdown, just give up */
 #if DEBUG_TRANSPORT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Shutdown while trying to transmit `%s' request.\n",
-                  "START");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Shutdown while trying to transmit `%s' request.\n", "START");
 #endif
-      return 0;
-    }
+    return 0;
+  }
 #if DEBUG_TRANSPORT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting `%s' request.\n", "START");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting `%s' request.\n", "START");
 #endif
   GNUNET_assert (size >= sizeof (struct StartMessage));
   s.header.size = htons (sizeof (struct StartMessage));
@@ -892,29 +874,25 @@ send_start (void *cls, size_t size, void *buf)
  * @param tc scheduler context
  */
 static void
-reconnect (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TRANSPORT_Handle *h = cls;
 
   h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    {
-      /* shutdown, just give up */
-      return;
-    }
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  {
+    /* shutdown, just give up */
+    return;
+  }
 #if DEBUG_TRANSPORT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connecting to transport service.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
 #endif
   GNUNET_assert (h->client == NULL);
   GNUNET_assert (h->control_head == NULL);
   GNUNET_assert (h->control_tail == NULL);
   h->client = GNUNET_CLIENT_connect ("transport", h->cfg);
   GNUNET_assert (h->client != NULL);
-  schedule_control_transmit (h,
-                             sizeof (struct StartMessage),
-                             &send_start, h);
+  schedule_control_transmit (h, sizeof (struct StartMessage), &send_start, h);
 }
 
 
@@ -931,50 +909,45 @@ disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_Handle *h)
 
   GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
   /* Forget about all neighbours that we used to be connected to */
-  GNUNET_CONTAINER_multihashmap_iterate(h->neighbours, 
-                                        &neighbour_delete, 
-                                        h);
+  GNUNET_CONTAINER_multihashmap_iterate (h->neighbours, &neighbour_delete, h);
   if (NULL != h->cth)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
-      h->cth = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
+    h->cth = NULL;
+  }
   if (NULL != h->client)
-    {
-      GNUNET_CLIENT_disconnect (h->client, GNUNET_YES);
-      h->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (h->client, GNUNET_YES);
+    h->client = NULL;
+  }
   if (h->quota_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (h->quota_task);
-      h->quota_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  while ( (NULL != (th = h->control_head)))
-    {
-      GNUNET_CONTAINER_DLL_remove (h->control_head,
-                                   h->control_tail,
-                                   th);
-      th->notify (th->notify_cls, 0, NULL);
-      GNUNET_free (th);
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->quota_task);
+    h->quota_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  while ((NULL != (th = h->control_head)))
+  {
+    GNUNET_CONTAINER_DLL_remove (h->control_head, h->control_tail, th);
+    th->notify (th->notify_cls, 0, NULL);
+    GNUNET_free (th);
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Scheduling task to reconnect to transport service in %llu ms.\n",
               h->reconnect_delay.rel_value);
 #endif
   h->reconnect_task
-    = GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
-                                    &reconnect, h);
+      = GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
   if (h->reconnect_delay.rel_value == 0)
-    {
-      h->reconnect_delay = GNUNET_TIME_UNIT_MILLISECONDS;
-    }
+  {
+    h->reconnect_delay = GNUNET_TIME_UNIT_MILLISECONDS;
+  }
   else
-    {
-      h->reconnect_delay = GNUNET_TIME_relative_multiply (h->reconnect_delay, 2);
-      h->reconnect_delay = GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_SECONDS,
-                                                     h->reconnect_delay);
-    }
+  {
+    h->reconnect_delay = GNUNET_TIME_relative_multiply (h->reconnect_delay, 2);
+    h->reconnect_delay = GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_SECONDS,
+                                                   h->reconnect_delay);
+  }
 }
 
 
@@ -1011,15 +984,14 @@ send_set_quota (void *cls, size_t size, void *buf)
   struct QuotaSetMessage msg;
 
   if (buf == NULL)
-    {
-      GNUNET_free (sqc);
-      return 0;
-    }
+  {
+    GNUNET_free (sqc);
+    return 0;
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Transmitting `%s' request with respect to `%4s'.\n",
-              "SET_QUOTA",
-              GNUNET_i2s (&sqc->target));
+              "SET_QUOTA", GNUNET_i2s (&sqc->target));
 #endif
   GNUNET_assert (size >= sizeof (struct QuotaSetMessage));
   msg.header.size = htons (sizeof (struct QuotaSetMessage));
@@ -1049,32 +1021,29 @@ GNUNET_TRANSPORT_set_quota (struct GNUNET_TRANSPORT_Handle *handle,
 {
   struct Neighbour *n;
   struct SetQuotaContext *sqc;
-   
+
   n = neighbour_find (handle, target);
   if (NULL == n)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Quota changed to %u for peer `%s', but I have no such neighbour!\n",
-                  (unsigned int) ntohl (quota_out.value__),
-                  GNUNET_i2s (target));
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Quota changed to %u for peer `%s', but I have no such neighbour!\n",
+                (unsigned int) ntohl (quota_out.value__), GNUNET_i2s (target));
+    return;
+  }
   GNUNET_assert (NULL != handle->client);
 #if DEBUG_TRANSPORT
   if (ntohl (quota_out.value__) != n->out_tracker.available_bytes_per_s__)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Quota changed from %u to %u for peer `%s'\n",
-                (unsigned int) n->out_tracker.available_bytes_per_s__,
-                (unsigned int) ntohl (quota_out.value__),
-                GNUNET_i2s (target));
+                "Quota changed from %u to %u for peer `%s'\n",
+                (unsigned int) n->out_tracker.available_bytes_per_s__,
+                (unsigned int) ntohl (quota_out.value__), GNUNET_i2s (target));
   else
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Quota remains at %u for peer `%s'\n",
-                (unsigned int) n->out_tracker.available_bytes_per_s__,
-                GNUNET_i2s (target));
+                "Quota remains at %u for peer `%s'\n",
+                (unsigned int) n->out_tracker.available_bytes_per_s__,
+                GNUNET_i2s (target));
 #endif
-  GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker,
-                                         quota_out);
+  GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, quota_out);
   sqc = GNUNET_malloc (sizeof (struct SetQuotaContext));
   sqc->target = *target;
   sqc->quota_in = quota_in;
@@ -1099,15 +1068,14 @@ send_try_connect (void *cls, size_t size, void *buf)
   struct TransportRequestConnectMessage msg;
 
   if (buf == NULL)
-    {
-      GNUNET_free (pid);
-      return 0;
-    }
+  {
+    GNUNET_free (pid);
+    return 0;
+  }
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Transmitting `%s' request with respect to `%4s'.\n",
-              "REQUEST_CONNECT",
-              GNUNET_i2s (pid));
+              "REQUEST_CONNECT", GNUNET_i2s (pid));
 #endif
   GNUNET_assert (size >= sizeof (struct TransportRequestConnectMessage));
   msg.header.size = htons (sizeof (struct TransportRequestConnectMessage));
@@ -1129,7 +1097,7 @@ send_try_connect (void *cls, size_t size, void *buf)
  */
 void
 GNUNET_TRANSPORT_try_connect (struct GNUNET_TRANSPORT_Handle *handle,
-                              const struct GNUNET_PeerIdentity *target)
+                              const struct GNUNET_PeerIdentity *target)
 {
   struct GNUNET_PeerIdentity *pid;
 
@@ -1158,18 +1126,16 @@ send_hello (void *cls, size_t size, void *buf)
   uint16_t ssize;
 
   if (buf == NULL)
-    {
+  {
 #if DEBUG_TRANSPORT_TIMEOUT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Timeout while trying to transmit `%s' request.\n",
-                  "HELLO");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout while trying to transmit `%s' request.\n", "HELLO");
 #endif
-      GNUNET_free (msg);
-      return 0;
-    }
+    GNUNET_free (msg);
+    return 0;
+  }
 #if DEBUG_TRANSPORT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting `%s' request.\n", "HELLO");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting `%s' request.\n", "HELLO");
 #endif
   ssize = ntohs (msg->size);
   GNUNET_assert (size >= ssize);
@@ -1193,8 +1159,7 @@ send_hello (void *cls, size_t size, void *buf)
 void
 GNUNET_TRANSPORT_offer_hello (struct GNUNET_TRANSPORT_Handle *handle,
                               const struct GNUNET_MessageHeader *hello,
-                              GNUNET_SCHEDULER_Task cont,
-                              void *cls)
+                              GNUNET_SCHEDULER_Task cont, void *cls)
 {
   uint16_t size;
   struct GNUNET_PeerIdentity peer;
@@ -1205,23 +1170,20 @@ GNUNET_TRANSPORT_offer_hello (struct GNUNET_TRANSPORT_Handle *handle,
   GNUNET_break (ntohs (hello->type) == GNUNET_MESSAGE_TYPE_HELLO);
   size = ntohs (hello->size);
   GNUNET_break (size >= sizeof (struct GNUNET_MessageHeader));
-  if (GNUNET_OK != GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message*) hello,
-                                        &peer))
-    {
-      GNUNET_break (0);
-      return;
-    }
-  msg = GNUNET_malloc(size);
+  if (GNUNET_OK !=
+      GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hello, &peer))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  msg = GNUNET_malloc (size);
   memcpy (msg, hello, size);
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Offering `%s' message of `%4s' to transport for validation.\n",
-              "HELLO",
-              GNUNET_i2s (&peer));
+              "Offering `%s' message of `%4s' to transport for validation.\n",
+              "HELLO", GNUNET_i2s (&peer));
 #endif
-  schedule_control_transmit (handle,
-                             size,
-                             &send_hello, msg);
+  schedule_control_transmit (handle, size, &send_hello, msg);
 }
 
 
@@ -1245,9 +1207,7 @@ GNUNET_TRANSPORT_get_hello (struct GNUNET_TRANSPORT_Handle *handle,
   hwl = GNUNET_malloc (sizeof (struct HelloWaitList));
   hwl->rec = rec;
   hwl->rec_cls = rec_cls;
-  GNUNET_CONTAINER_DLL_insert (handle->hwl_head,
-                               handle->hwl_tail,
-                               hwl);
+  GNUNET_CONTAINER_DLL_insert (handle->hwl_head, handle->hwl_tail, hwl);
   if (handle->my_hello == NULL)
     return;
   rec (rec_cls, (const struct GNUNET_MessageHeader *) handle->my_hello);
@@ -1263,25 +1223,22 @@ GNUNET_TRANSPORT_get_hello (struct GNUNET_TRANSPORT_Handle *handle,
  */
 void
 GNUNET_TRANSPORT_get_hello_cancel (struct GNUNET_TRANSPORT_Handle *handle,
-                                   GNUNET_TRANSPORT_HelloUpdateCallback rec,
-                                   void *rec_cls)
+                                   GNUNET_TRANSPORT_HelloUpdateCallback rec,
+                                   void *rec_cls)
 {
   struct HelloWaitList *pos;
 
   pos = handle->hwl_head;
   while (pos != NULL)
-    {
-      if ( (pos->rec == rec) &&
-           (pos->rec_cls == rec_cls) )
-        break;
-      pos = pos->next;
-    }
+  {
+    if ((pos->rec == rec) && (pos->rec_cls == rec_cls))
+      break;
+    pos = pos->next;
+  }
   GNUNET_break (pos != NULL);
   if (pos == NULL)
     return;
-  GNUNET_CONTAINER_DLL_remove (handle->hwl_head,
-                               handle->hwl_tail,
-                               pos);
+  GNUNET_CONTAINER_DLL_remove (handle->hwl_head, handle->hwl_tail, pos);
   GNUNET_free (pos);
 }
 
@@ -1300,7 +1257,7 @@ GNUNET_TRANSPORT_get_hello_cancel (struct GNUNET_TRANSPORT_Handle *handle,
  */
 struct GNUNET_TRANSPORT_Handle *
 GNUNET_TRANSPORT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                          const struct GNUNET_PeerIdentity *self,
+                          const struct GNUNET_PeerIdentity *self,
                           void *cls,
                           GNUNET_TRANSPORT_ReceiveCallback rec,
                           GNUNET_TRANSPORT_NotifyConnect nc,
@@ -1310,18 +1267,20 @@ GNUNET_TRANSPORT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
   ret = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_Handle));
   if (self != NULL)
-    {
-      ret->self = *self;
-      ret->check_self = GNUNET_YES;
-    }
+  {
+    ret->self = *self;
+    ret->check_self = GNUNET_YES;
+  }
   ret->cfg = cfg;
   ret->cls = cls;
   ret->rec = rec;
   ret->nc_cb = nc;
   ret->nd_cb = nd;
   ret->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
-  ret->neighbours = GNUNET_CONTAINER_multihashmap_create(STARTING_NEIGHBOURS_SIZE);
-  ret->ready_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  ret->neighbours =
+      GNUNET_CONTAINER_multihashmap_create (STARTING_NEIGHBOURS_SIZE);
+  ret->ready_heap =
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   ret->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, ret);
   return ret;
 }
@@ -1336,25 +1295,24 @@ void
 GNUNET_TRANSPORT_disconnect (struct GNUNET_TRANSPORT_Handle *handle)
 {
 #if DEBUG_TRANSPORT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Transport disconnect called!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
 #endif
   /* this disconnects all neighbours... */
   if (handle->reconnect_task == GNUNET_SCHEDULER_NO_TASK)
     disconnect_and_schedule_reconnect (handle);
   /* and now we stop trying to connect again... */
   if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (handle->reconnect_task);
-      handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
-    }  
+  {
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
+    handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_CONTAINER_multihashmap_destroy (handle->neighbours);
   handle->neighbours = NULL;
   if (handle->quota_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (handle->quota_task);
-      handle->quota_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (handle->quota_task);
+    handle->quota_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_free_non_null (handle->my_hello);
   handle->my_hello = NULL;
   GNUNET_assert (handle->hwl_head == NULL);
@@ -1386,31 +1344,30 @@ GNUNET_TRANSPORT_disconnect (struct GNUNET_TRANSPORT_Handle *handle)
  */
 struct GNUNET_TRANSPORT_TransmitHandle *
 GNUNET_TRANSPORT_notify_transmit_ready (struct GNUNET_TRANSPORT_Handle *handle,
-                                        const struct GNUNET_PeerIdentity *target,
-                                        size_t size,
-                                        uint32_t priority,
+                                        const struct GNUNET_PeerIdentity
+                                        *target, size_t size, uint32_t priority,
                                         struct GNUNET_TIME_Relative timeout,
-                                        GNUNET_CONNECTION_TransmitReadyNotify notify, 
-                                        void *notify_cls)
+                                        GNUNET_CONNECTION_TransmitReadyNotify
+                                        notify, void *notify_cls)
 {
   struct Neighbour *n;
   struct GNUNET_TRANSPORT_TransmitHandle *th;
   struct GNUNET_TIME_Relative delay;
-  
+
   n = neighbour_find (handle, target);
   if (NULL == n)
-    {
-      /* use GNUNET_TRANSPORT_try_connect first, only use this function
-         once a connection has been established */
-      GNUNET_assert (0);
-      return NULL;
-    }
+  {
+    /* use GNUNET_TRANSPORT_try_connect first, only use this function
+     * once a connection has been established */
+    GNUNET_assert (0);
+    return NULL;
+  }
   if (NULL != n->th)
-    {
-      /* attempt to send two messages at the same time to the same peer */
-      GNUNET_assert (0);
-      return NULL;
-    }
+  {
+    /* attempt to send two messages at the same time to the same peer */
+    GNUNET_assert (0);
+    return NULL;
+  }
   GNUNET_assert (NULL == n->hn);
   th = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TransmitHandle));
   th->neighbour = n;
@@ -1423,16 +1380,13 @@ GNUNET_TRANSPORT_notify_transmit_ready (struct GNUNET_TRANSPORT_Handle *handle,
   /* calculate when our transmission should be ready */
   delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, size);
   if (delay.rel_value > timeout.rel_value)
-    delay.rel_value = 0; /* notify immediately (with failure) */
+    delay.rel_value = 0;        /* notify immediately (with failure) */
 #if DEBUG_TRANSPORT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Bandwidth tracker allows next transmission to peer %s in %llu ms\n",
-              GNUNET_i2s (target),
-              (unsigned long long) delay.rel_value);
+              "Bandwidth tracker allows next transmission to peer %s in %llu ms\n",
+              GNUNET_i2s (target), (unsigned long long) delay.rel_value);
 #endif
-  n->hn = GNUNET_CONTAINER_heap_insert (handle->ready_heap,
-                                        n, 
-                                        delay.rel_value);
+  n->hn = GNUNET_CONTAINER_heap_insert (handle->ready_heap, n, delay.rel_value);
   schedule_transmission (handle);
   return th;
 }
@@ -1444,7 +1398,9 @@ GNUNET_TRANSPORT_notify_transmit_ready (struct GNUNET_TRANSPORT_Handle *handle,
  * @param th handle returned from GNUNET_TRANSPORT_notify_transmit_ready
  */
 void
-GNUNET_TRANSPORT_notify_transmit_ready_cancel (struct GNUNET_TRANSPORT_TransmitHandle *th)
+GNUNET_TRANSPORT_notify_transmit_ready_cancel (struct
+                                               GNUNET_TRANSPORT_TransmitHandle
+                                               *th)
 {
   struct Neighbour *n;
 
@@ -1454,17 +1410,17 @@ GNUNET_TRANSPORT_notify_transmit_ready_cancel (struct GNUNET_TRANSPORT_TransmitH
   GNUNET_assert (th == n->th);
   n->th = NULL;
   if (n->hn != NULL)
-    {
-      GNUNET_CONTAINER_heap_remove_node (n->hn);
-      n->hn = NULL;
-    }
+  {
+    GNUNET_CONTAINER_heap_remove_node (n->hn);
+    n->hn = NULL;
+  }
   else
-    {
-      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != th->timeout_task);
-      GNUNET_SCHEDULER_cancel (th->timeout_task);
-      th->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  GNUNET_free (th);                                        
+  {
+    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != th->timeout_task);
+    GNUNET_SCHEDULER_cancel (th->timeout_task);
+    th->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  GNUNET_free (th);
 }
 
 
diff --git a/src/transport/transport_api_address_iterate.c b/src/transport/transport_api_address_iterate.c
index 7bbeb499d..4f442fda0 100644
--- a/src/transport/transport_api_address_iterate.c
+++ b/src/transport/transport_api_address_iterate.c
@@ -82,37 +82,37 @@ peer_address_response_processor (void *cls,
   uint16_t size;
 
   if (msg == NULL)
-    {
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
-  GNUNET_break (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+  {
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
+  GNUNET_break (ntohs (msg->type) ==
+                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
   size = ntohs (msg->size);
   if (size == sizeof (struct GNUNET_MessageHeader))
-    {
-      /* done! */
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
+  {
+    /* done! */
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
   address = (const char *) &msg[1];
   if (address[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
-    {
-      /* invalid reply */
-      GNUNET_break (0);
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
+  {
+    /* invalid reply */
+    GNUNET_break (0);
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
   /* expect more replies */
   GNUNET_CLIENT_receive (alucb->client,
-                         &peer_address_response_processor, alucb,
-                         GNUNET_TIME_absolute_get_remaining
-                         (alucb->timeout));
+                         &peer_address_response_processor, alucb,
+                         GNUNET_TIME_absolute_get_remaining (alucb->timeout));
   alucb->cb (alucb->cb_cls, address);
 }
 
@@ -128,7 +128,8 @@ peer_address_response_processor (void *cls,
 void
 GNUNET_TRANSPORT_address_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                   struct GNUNET_TIME_Relative timeout,
-                                  GNUNET_TRANSPORT_AddressLookUpCallback peer_address_callback,
+                                  GNUNET_TRANSPORT_AddressLookUpCallback
+                                  peer_address_callback,
                                   void *peer_address_callback_cls)
 {
   struct AddressIterateMessage msg;
@@ -138,13 +139,13 @@ GNUNET_TRANSPORT_address_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
   client = GNUNET_CLIENT_connect ("transport", cfg);
   if (client == NULL)
-    {
-      peer_address_callback (peer_address_callback_cls, NULL);
-      return;
-    }
+  {
+    peer_address_callback (peer_address_callback_cls, NULL);
+    return;
+  }
   abs_timeout = GNUNET_TIME_relative_to_absolute (timeout);
 
-  msg.header.size = htons (sizeof(struct AddressLookupMessage));
+  msg.header.size = htons (sizeof (struct AddressLookupMessage));
   msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE);
   msg.timeout = GNUNET_TIME_absolute_hton (abs_timeout);
   peer_address_lookup_cb = GNUNET_malloc (sizeof (struct AddressLookupCtx));
@@ -153,12 +154,12 @@ GNUNET_TRANSPORT_address_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
   peer_address_lookup_cb->timeout = abs_timeout;
   peer_address_lookup_cb->client = client;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CLIENT_transmit_and_get_response (client,
-                                                          &msg.header,
-                                                          timeout,
-                                                          GNUNET_YES,
-                                                          &peer_address_response_processor,
-                                                          peer_address_lookup_cb));
+                 GNUNET_CLIENT_transmit_and_get_response (client,
+                                                          &msg.header,
+                                                          timeout,
+                                                          GNUNET_YES,
+                                                          &peer_address_response_processor,
+                                                          peer_address_lookup_cb));
 }
 
 /* end of transport_api_address_iterate.c */
diff --git a/src/transport/transport_api_address_lookup.c b/src/transport/transport_api_address_lookup.c
index 619e60a43..4aadf10f4 100644
--- a/src/transport/transport_api_address_lookup.c
+++ b/src/transport/transport_api_address_lookup.c
@@ -62,45 +62,44 @@ struct AddressLookupCtx
  *        message with the human-readable address
  */
 static void
-address_response_processor (void *cls,
-                            const struct GNUNET_MessageHeader *msg)
+address_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct AddressLookupCtx *alucb = cls;
   const char *address;
   uint16_t size;
 
   if (msg == NULL)
-    {
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
-  GNUNET_break (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+  {
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
+  GNUNET_break (ntohs (msg->type) ==
+                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
   size = ntohs (msg->size);
   if (size == sizeof (struct GNUNET_MessageHeader))
-    {
-      /* done! */
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
+  {
+    /* done! */
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
   address = (const char *) &msg[1];
   if (address[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
-    {
-      /* invalid reply */
-      GNUNET_break (0);
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
+  {
+    /* invalid reply */
+    GNUNET_break (0);
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
   /* expect more replies */
   GNUNET_CLIENT_receive (alucb->client,
-                         &address_response_processor, alucb,
-                         GNUNET_TIME_absolute_get_remaining
-                         (alucb->timeout));
+                         &address_response_processor, alucb,
+                         GNUNET_TIME_absolute_get_remaining (alucb->timeout));
   alucb->cb (alucb->cb_cls, address);
 }
 
@@ -120,9 +119,9 @@ address_response_processor (void *cls,
  */
 void
 GNUNET_TRANSPORT_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                                 const char *address,
-                                 size_t addressLen,
-                                 int numeric,
+                                 const char *address,
+                                 size_t addressLen,
+                                 int numeric,
                                  const char *nameTrans,
                                  struct GNUNET_TIME_Relative timeout,
                                  GNUNET_TRANSPORT_AddressLookUpCallback aluc,
@@ -138,17 +137,17 @@ GNUNET_TRANSPORT_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg,
   slen = strlen (nameTrans) + 1;
   len = sizeof (struct AddressLookupMessage) + addressLen + slen;
   if (len >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      aluc (aluc_cls, NULL);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    aluc (aluc_cls, NULL);
+    return;
+  }
   client = GNUNET_CLIENT_connect ("transport", cfg);
   if (client == NULL)
-    {
-      aluc (aluc_cls, NULL);
-      return;
-    }
+  {
+    aluc (aluc_cls, NULL);
+    return;
+  }
   msg = GNUNET_malloc (len);
   msg->header.size = htons (len);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP);
@@ -164,12 +163,12 @@ GNUNET_TRANSPORT_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg,
   aluCB->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   aluCB->client = client;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CLIENT_transmit_and_get_response (client,
-                                                          &msg->header,
-                                                          timeout,
-                                                          GNUNET_YES,
-                                                          &address_response_processor,
-                                                          aluCB));
+                 GNUNET_CLIENT_transmit_and_get_response (client,
+                                                          &msg->header,
+                                                          timeout,
+                                                          GNUNET_YES,
+                                                          &address_response_processor,
+                                                          aluCB));
   GNUNET_free (msg);
 }
 
diff --git a/src/transport/transport_api_blacklist.c b/src/transport/transport_api_blacklist.c
index 2315b515f..f8f430995 100644
--- a/src/transport/transport_api_blacklist.c
+++ b/src/transport/transport_api_blacklist.c
@@ -42,7 +42,7 @@ struct GNUNET_TRANSPORT_Blacklist
   /**
    * Connection to transport service.
    */
-  struct GNUNET_CLIENT_Connection * client;
+  struct GNUNET_CLIENT_Connection *client;
 
   /**
    * Configuration to use.
@@ -78,8 +78,7 @@ struct GNUNET_TRANSPORT_Blacklist
  *
  * @param br overall handle
  */
-static void
-reconnect (struct GNUNET_TRANSPORT_Blacklist *br);
+static void reconnect (struct GNUNET_TRANSPORT_Blacklist *br);
 
 
 /**
@@ -87,8 +86,7 @@ reconnect (struct GNUNET_TRANSPORT_Blacklist *br);
  *
  * @param br our overall context
  */
-static void
-reply (struct GNUNET_TRANSPORT_Blacklist *br);
+static void reply (struct GNUNET_TRANSPORT_Blacklist *br);
 
 
 /**
@@ -98,19 +96,18 @@ reply (struct GNUNET_TRANSPORT_Blacklist *br);
  * @param msg query
  */
 static void
-query_handler (void *cls,
-               const struct GNUNET_MessageHeader *msg)
+query_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_TRANSPORT_Blacklist *br = cls;
   const struct BlacklistMessage *bm;
 
-  if ( (ntohs(msg->size) != sizeof (struct BlacklistMessage)) ||
-       (ntohs(msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY) )
-    {
-      reconnect (br);
-      return;
-    }
-  bm = (const struct BlacklistMessage *)msg;
+  if ((ntohs (msg->size) != sizeof (struct BlacklistMessage)) ||
+      (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY))
+  {
+    reconnect (br);
+    return;
+  }
+  bm = (const struct BlacklistMessage *) msg;
   GNUNET_break (0 == ntohl (bm->is_allowed));
   br->peer = bm->peer;
   reply (br);
@@ -126,9 +123,7 @@ static void
 receive (struct GNUNET_TRANSPORT_Blacklist *br)
 {
   GNUNET_CLIENT_receive (br->client,
-                         &query_handler,
-                         br,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &query_handler, br, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -141,17 +136,16 @@ receive (struct GNUNET_TRANSPORT_Blacklist *br)
  * @return number of bytes written to buf
  */
 static size_t
-transmit_blacklist_init (void *cls,
-                         size_t size, void *buf)
+transmit_blacklist_init (void *cls, size_t size, void *buf)
 {
   struct GNUNET_TRANSPORT_Blacklist *br = cls;
   struct GNUNET_MessageHeader req;
 
   if (buf == NULL)
-    {
-      reconnect (br);
-      return 0;
-    }
+  {
+    reconnect (br);
+    return 0;
+  }
   req.size = htons (sizeof (struct GNUNET_MessageHeader));
   req.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT);
   memcpy (buf, &req, sizeof (req));
@@ -170,15 +164,14 @@ reconnect (struct GNUNET_TRANSPORT_Blacklist *br)
 {
   if (br->client != NULL)
     GNUNET_CLIENT_disconnect (br->client, GNUNET_NO);
-  br->client = GNUNET_CLIENT_connect ("transport",
-                                      br->cfg);
+  br->client = GNUNET_CLIENT_connect ("transport", br->cfg);
   GNUNET_assert (br->client != NULL);
   br->th = GNUNET_CLIENT_notify_transmit_ready (br->client,
-                                                sizeof (struct GNUNET_MessageHeader),
-                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                                GNUNET_YES,
-                                                &transmit_blacklist_init,
-                                                br);
+                                                sizeof (struct
+                                                        GNUNET_MessageHeader),
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                GNUNET_YES,
+                                                &transmit_blacklist_init, br);
 }
 
 
@@ -191,17 +184,16 @@ reconnect (struct GNUNET_TRANSPORT_Blacklist *br)
  * @return number of bytes written to buf
  */
 static size_t
-transmit_blacklist_reply (void *cls,
-                          size_t size, void *buf)
+transmit_blacklist_reply (void *cls, size_t size, void *buf)
 {
   struct GNUNET_TRANSPORT_Blacklist *br = cls;
   struct BlacklistMessage req;
 
   if (buf == NULL)
-    {
-      reconnect (br);
-      return 0;
-    }
+  {
+    reconnect (br);
+    return 0;
+  }
   req.header.size = htons (sizeof (req));
   req.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY);
   req.is_allowed = htonl (br->cb (br->cb_cls, &br->peer));
@@ -221,16 +213,16 @@ static void
 reply (struct GNUNET_TRANSPORT_Blacklist *br)
 {
   br->th = GNUNET_CLIENT_notify_transmit_ready (br->client,
-                                                sizeof (struct BlacklistMessage),
-                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                                GNUNET_NO,
-                                                &transmit_blacklist_reply,
-                                                br);
+                                                sizeof (struct
+                                                        BlacklistMessage),
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                GNUNET_NO,
+                                                &transmit_blacklist_reply, br);
   if (br->th == NULL)
-    {
-      reconnect (br);
-      return;
-    }
+  {
+    reconnect (br);
+    return;
+  }
 }
 
 
@@ -250,10 +242,9 @@ reply (struct GNUNET_TRANSPORT_Blacklist *br)
  */
 struct GNUNET_TRANSPORT_Blacklist *
 GNUNET_TRANSPORT_blacklist (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                            GNUNET_TRANSPORT_BlacklistCallback cb,
-                            void *cb_cls)
+                            GNUNET_TRANSPORT_BlacklistCallback cb, void *cb_cls)
 {
-  struct GNUNET_CLIENT_Connection * client;
+  struct GNUNET_CLIENT_Connection *client;
   struct GNUNET_TRANSPORT_Blacklist *ret;
 
   client = GNUNET_CLIENT_connect ("transport", cfg);
@@ -263,11 +254,11 @@ GNUNET_TRANSPORT_blacklist (const struct GNUNET_CONFIGURATION_Handle *cfg,
   ret->client = client;
   ret->cfg = cfg;
   ret->th = GNUNET_CLIENT_notify_transmit_ready (client,
-                                                 sizeof (struct GNUNET_MessageHeader),
-                                                 GNUNET_TIME_UNIT_FOREVER_REL,
-                                                 GNUNET_YES,
-                                                 &transmit_blacklist_init,
-                                                 ret);
+                                                 sizeof (struct
+                                                         GNUNET_MessageHeader),
+                                                 GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 GNUNET_YES,
+                                                 &transmit_blacklist_init, ret);
   return ret;
 }
 
diff --git a/src/transport/transport_api_peer_address_lookup.c b/src/transport/transport_api_peer_address_lookup.c
index c63856d4a..50536b47d 100644
--- a/src/transport/transport_api_peer_address_lookup.c
+++ b/src/transport/transport_api_peer_address_lookup.c
@@ -82,37 +82,37 @@ peer_address_response_processor (void *cls,
   uint16_t size;
 
   if (msg == NULL)
-    {
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
-  GNUNET_break (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
+  {
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
+  GNUNET_break (ntohs (msg->type) ==
+                GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
   size = ntohs (msg->size);
   if (size == sizeof (struct GNUNET_MessageHeader))
-    {
-      /* done! */
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
+  {
+    /* done! */
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
   address = (const char *) &msg[1];
   if (address[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
-    {
-      /* invalid reply */
-      GNUNET_break (0);
-      alucb->cb (alucb->cb_cls, NULL);
-      GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
-      GNUNET_free (alucb);
-      return;
-    }
+  {
+    /* invalid reply */
+    GNUNET_break (0);
+    alucb->cb (alucb->cb_cls, NULL);
+    GNUNET_CLIENT_disconnect (alucb->client, GNUNET_NO);
+    GNUNET_free (alucb);
+    return;
+  }
   /* expect more replies */
   GNUNET_CLIENT_receive (alucb->client,
-                         &peer_address_response_processor, alucb,
-                         GNUNET_TIME_absolute_get_remaining
-                         (alucb->timeout));
+                         &peer_address_response_processor, alucb,
+                         GNUNET_TIME_absolute_get_remaining (alucb->timeout));
   alucb->cb (alucb->cb_cls, address);
 }
 
@@ -127,10 +127,12 @@ peer_address_response_processor (void *cls,
  * @param peer_address_callback_cls closure for peer_address_callback
  */
 void
-GNUNET_TRANSPORT_peer_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TRANSPORT_peer_address_lookup (const struct GNUNET_CONFIGURATION_Handle
+                                      *cfg,
                                       const struct GNUNET_PeerIdentity *peer,
                                       struct GNUNET_TIME_Relative timeout,
-                                      GNUNET_TRANSPORT_AddressLookUpCallback peer_address_callback,
+                                      GNUNET_TRANSPORT_AddressLookUpCallback
+                                      peer_address_callback,
                                       void *peer_address_callback_cls)
 {
   struct PeerAddressLookupMessage msg;
@@ -139,26 +141,26 @@ GNUNET_TRANSPORT_peer_address_lookup (const struct GNUNET_CONFIGURATION_Handle *
 
   client = GNUNET_CLIENT_connect ("transport", cfg);
   if (client == NULL)
-    {
-      peer_address_callback (peer_address_callback_cls, NULL);
-      return;
-    }
-  msg.header.size = htons (sizeof(struct PeerAddressLookupMessage));
+  {
+    peer_address_callback (peer_address_callback_cls, NULL);
+    return;
+  }
+  msg.header.size = htons (sizeof (struct PeerAddressLookupMessage));
   msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PEER_ADDRESS_LOOKUP);
   msg.timeout = GNUNET_TIME_relative_hton (timeout);
-  memcpy(&msg.peer, peer, sizeof(struct GNUNET_PeerIdentity));
+  memcpy (&msg.peer, peer, sizeof (struct GNUNET_PeerIdentity));
   peer_address_lookup_cb = GNUNET_malloc (sizeof (struct AddressLookupCtx));
   peer_address_lookup_cb->cb = peer_address_callback;
   peer_address_lookup_cb->cb_cls = peer_address_callback_cls;
   peer_address_lookup_cb->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   peer_address_lookup_cb->client = client;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CLIENT_transmit_and_get_response (client,
-                                                          &msg.header,
-                                                          timeout,
-                                                          GNUNET_YES,
-                                                          &peer_address_response_processor,
-                                                          peer_address_lookup_cb));
+                 GNUNET_CLIENT_transmit_and_get_response (client,
+                                                          &msg.header,
+                                                          timeout,
+                                                          GNUNET_YES,
+                                                          &peer_address_response_processor,
+                                                          peer_address_lookup_cb));
 }
 
 /* end of transport_api_peer_address_lookup.c */
diff --git a/src/transport/wlan/byteorder.h b/src/transport/wlan/byteorder.h
index c982669bf..e065e24d6 100644
--- a/src/transport/wlan/byteorder.h
+++ b/src/transport/wlan/byteorder.h
@@ -16,418 +16,421 @@
  *  You should have received a copy of the GNU General Public License

  *  along with this program; if not, write to the Free Software

  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

- */

-

+ */  

+    

 #ifndef _AIRCRACK_NG_BYTEORDER_H_

 #define _AIRCRACK_NG_BYTEORDER_H_

-

-        #define ___my_swab16(x) \

-        ((u_int16_t)( \

-                        (((u_int16_t)(x) & (u_int16_t)0x00ffU) << 8) | \

-                        (((u_int16_t)(x) & (u_int16_t)0xff00U) >> 8) ))

-        #define ___my_swab32(x) \

-        ((u_int32_t)( \

-                        (((u_int32_t)(x) & (u_int32_t)0x000000ffUL) << 24) | \

-                        (((u_int32_t)(x) & (u_int32_t)0x0000ff00UL) <<  8) | \

-                        (((u_int32_t)(x) & (u_int32_t)0x00ff0000UL) >>  8) | \

-                        (((u_int32_t)(x) & (u_int32_t)0xff000000UL) >> 24) ))

-        #define ___my_swab64(x) \

-        ((u_int64_t)( \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00000000000000ffULL) << 56) | \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x000000000000ff00ULL) << 40) | \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x0000000000ff0000ULL) << 24) | \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00000000ff000000ULL) <<  8) | \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x000000ff00000000ULL) >>  8) | \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x0000ff0000000000ULL) >> 24) | \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00ff000000000000ULL) >> 40) | \

-                        (u_int64_t)(((u_int64_t)(x) & (u_int64_t)0xff00000000000000ULL) >> 56) ))

-

-

-        /*

-         * Linux

-         */

-        #if defined(linux) || defined(Linux) || defined(__linux__) || defined(__linux) || defined(__gnu_linux__)

-                #include <endian.h>

-                #include <unistd.h>

-                #include <stdint.h>

-

-                #ifndef __int8_t_defined

-                        typedef uint64_t u_int64_t;

-                        typedef uint32_t u_int32_t;

-                        typedef uint16_t u_int16_t;

-                        typedef uint8_t  u_int8_t;

-                #endif

-

+    

+#define ___my_swab16(x) \

+    ((u_int16_t) (\

+                  (((u_int16_t) (x) & (u_int16_t) 0x00ffU) << 8) | \

+                  (((u_int16_t) (x) & (u_int16_t) 0xff00U) >> 8))) 

+#define ___my_swab32(x) \

+    ((u_int32_t) (\

+                  (((u_int32_t) (x) & (u_int32_t) 0x000000ffUL) << 24) | \

+                  (((u_int32_t) (x) & (u_int32_t) 0x0000ff00UL) << 8) | \

+                  (((u_int32_t) (x) & (u_int32_t) 0x00ff0000UL) >> 8) | \

+                  (((u_int32_t) (x) & (u_int32_t) 0xff000000UL) >> 24))) 

+#define ___my_swab64(x) \

+    ((u_int64_t) (\

+                  (u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                0x00000000000000ffULL) << 56) |
+                  \
(u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                  0x000000000000ff00ULL) << 40) |
+                  \
(u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                  0x0000000000ff0000ULL) << 24) |
+                  \
(u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                  0x00000000ff000000ULL) << 8) |
+                  \
(u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                  0x000000ff00000000ULL) >> 8) |
+                  \
(u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                  0x0000ff0000000000ULL) >> 24) |
+                  \
(u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                  0x00ff000000000000ULL) >> 40) |
+                  \
(u_int64_t) (((u_int64_t) (x) & (u_int64_t)
+                                  0xff00000000000000ULL) >> 56))) 
 
 

+    /*

+     * Linux

+     */ 

+#if defined(linux) || defined(Linux) || defined(__linux__) || defined(__linux) || defined(__gnu_linux__)

+#include <endian.h>

+#include <unistd.h>

+#include <stdint.h>

+    

+#ifndef __int8_t_defined

+typedef uint64_t u_int64_t;
+
typedef uint32_t u_int32_t;
+
typedef uint16_t u_int16_t;
+
typedef uint8_t u_int8_t;
+
+

+#endif /* 
 */
+    

 #ifndef htole16

-# if __BYTE_ORDER == __LITTLE_ENDIAN

-#  define htobe16(x) ___my_swab16 (x)

-#  define htole16(x) (x)

-#  define be16toh(x) ___my_swab16 (x)

-#  define le16toh(x) (x)

-

-#  define htobe32(x) ___my_swab32 (x)

-#  define htole32(x) (x)

-#  define be32toh(x) ___my_swab32 (x)

-#  define le32toh(x) (x)

-

-#  define htobe64(x) ___my_swab64 (x)

-#  define htole64(x) (x)

-#  define be64toh(x) ___my_swab64 (x)

-#  define le64toh(x) (x)

-# else

-#  define htobe16(x) (x)

-#  define htole16(x) ___my_swab16 (x)

-#  define be16toh(x) (x)

-#  define le16toh(x) ___my_swab16 (x)

-

-#  define htobe32(x) (x)

-#  define htole32(x) ___my_swab32 (x)

-#  define be32toh(x) (x)

-#  define le32toh(x) ___my_swab32 (x)

-

-#  define htobe64(x) (x)

-#  define htole64(x) ___my_swab64 (x)

-#  define be64toh(x) (x)

-#  define le64toh(x) ___my_swab64 (x)

-# endif

-#endif

-

-

-

-        #endif

-

-        /*

-         * Cygwin

-         */

-        #if defined(__CYGWIN32__)

-                #include <asm/byteorder.h>

-                #include <unistd.h>

-

-                #define __be64_to_cpu(x) ___my_swab64(x)

-                #define __be32_to_cpu(x) ___my_swab32(x)

-                #define __be16_to_cpu(x) ___my_swab16(x)

-                #define __cpu_to_be64(x) ___my_swab64(x)

-                #define __cpu_to_be32(x) ___my_swab32(x)

-                #define __cpu_to_be16(x) ___my_swab16(x)

-                #define __le64_to_cpu(x) (x)

-                #define __le32_to_cpu(x) (x)

-                #define __le16_to_cpu(x) (x)

-                #define __cpu_to_le64(x) (x)

-                #define __cpu_to_le32(x) (x)

-                #define __cpu_to_le16(x) (x)

-

-                #define AIRCRACK_NG_BYTE_ORDER_DEFINED

-

-        #endif

-

-        /*

-         * Windows (DDK)

-         */

-        #if defined(__WIN__)

-

-                #include <io.h>

-

-                #define __be64_to_cpu(x) ___my_swab64(x)

-                #define __be32_to_cpu(x) ___my_swab32(x)

-                #define __be16_to_cpu(x) ___my_swab16(x)

-                #define __cpu_to_be64(x) ___my_swab64(x)

-                #define __cpu_to_be32(x) ___my_swab32(x)

-                #define __cpu_to_be16(x) ___my_swab16(x)

-                #define __le64_to_cpu(x) (x)

-                #define __le32_to_cpu(x) (x)

-                #define __le16_to_cpu(x) (x)

-                #define __cpu_to_le64(x) (x)

-                #define __cpu_to_le32(x) (x)

-                #define __cpu_to_le16(x) (x)

-

-                #define AIRCRACK_NG_BYTE_ORDER_DEFINED

-

-        #endif

-

-        /*

-         * MAC (Darwin)

-         */

-        #if defined(__APPLE_CC__)

-                #if defined(__x86_64__) && defined(__APPLE__)

-

-                        #include <libkern/OSByteOrder.h>

-

-                        #define __swab64(x)      (unsigned long long) OSSwapInt64((uint64_t)x)

-                        #define __swab32(x)      (unsigned long) OSSwapInt32((uint32_t)x)

-                        #define __swab16(x)      (unsigned short) OSSwapInt16((uint16_t)x)

-                        #define __be64_to_cpu(x) (unsigned long long) OSSwapBigToHostInt64((uint64_t)x)

-                        #define __be32_to_cpu(x) (unsigned long) OSSwapBigToHostInt32((uint32_t)x)

-                        #define __be16_to_cpu(x) (unsigned short) OSSwapBigToHostInt16((uint16_t)x)

-                        #define __le64_to_cpu(x) (unsigned long long) OSSwapLittleToHostInt64((uint64_t)x)

-                        #define __le32_to_cpu(x) (unsigned long) OSSwapLittleToHostInt32((uint32_t)x)

-                        #define __le16_to_cpu(x) (unsigned short) OSSwapLittleToHostInt16((uint16_t)x)

-                        #define __cpu_to_be64(x) (unsigned long long) OSSwapHostToBigInt64((uint64_t)x)

-                        #define __cpu_to_be32(x) (unsigned long) OSSwapHostToBigInt32((uint32_t)x)

-                        #define __cpu_to_be16(x) (unsigned short) OSSwapHostToBigInt16((uint16_t)x)

-                        #define __cpu_to_le64(x) (unsigned long long) OSSwapHostToLittleInt64((uint64_t)x)

-                        #define __cpu_to_le32(x) (unsigned long) OSSwapHostToLittleInt32((uint32_t)x)

-                        #define __cpu_to_le16(x) (unsigned short) OSSwapHostToLittleInt16((uint16_t)x)

-

-                #else

-

-                        #include <architecture/byte_order.h>

-

-                        #define __swab64(x)      NXSwapLongLong(x)

-                        #define __swab32(x)      NXSwapLong(x)

-                        #define __swab16(x)      NXSwapShort(x)

-                        #define __be64_to_cpu(x) NXSwapBigLongLongToHost(x)

-                        #define __be32_to_cpu(x) NXSwapBigLongToHost(x)

-                        #define __be16_to_cpu(x) NXSwapBigShortToHost(x)

-                        #define __le64_to_cpu(x) NXSwapLittleLongLongToHost(x)

-                        #define __le32_to_cpu(x) NXSwapLittleLongToHost(x)

-                        #define __le16_to_cpu(x) NXSwapLittleShortToHost(x)

-                        #define __cpu_to_be64(x) NXSwapHostLongLongToBig(x)

-                        #define __cpu_to_be32(x) NXSwapHostLongToBig(x)

-                        #define __cpu_to_be16(x) NXSwapHostShortToBig(x)

-                        #define __cpu_to_le64(x) NXSwapHostLongLongToLittle(x)

-                        #define __cpu_to_le32(x) NXSwapHostLongToLittle(x)

-                        #define __cpu_to_le16(x) NXSwapHostShortToLittle(x)

-

-                #endif

-

-                #define __LITTLE_ENDIAN 1234

-                #define __BIG_ENDIAN    4321

-                #define __PDP_ENDIAN    3412

-                #define __BYTE_ORDER    __BIG_ENDIAN

-

-                #define AIRCRACK_NG_BYTE_ORDER_DEFINED

-

-        #endif

-

-        /*

-         * Solaris

-         * -------

-         */

-        #if defined(__sparc__) && defined(__sun__)

-        #include <sys/byteorder.h>

-        #include <sys/types.h>

-        #include <unistd.h>

-

-                #define __be64_to_cpu(x) (x)

-                #define __be32_to_cpu(x) (x)

-                #define __be16_to_cpu(x) (x)

-                #define __cpu_to_be64(x) (x)

-                #define __cpu_to_be32(x) (x)

-                #define __cpu_to_be16(x) (x)

-                #define __le64_to_cpu(x) ___my_swab64(x)

-                #define __le32_to_cpu(x) ___my_swab32(x)

-                #define __le16_to_cpu(x) ___my_swab16(x)

-                #define __cpu_to_le64(x) ___my_swab64(x)

-                #define __cpu_to_le32(x) ___my_swab32(x)

-                #define __cpu_to_le16(x) ___my_swab16(x)

-

-                typedef uint64_t u_int64_t;

-                typedef uint32_t u_int32_t;

-                typedef uint16_t u_int16_t;

-                typedef uint8_t  u_int8_t;

-

-                #define AIRCRACK_NG_BYTE_ORDER_DEFINED

-

-        #endif

-

-        /*

-         * Custom stuff

-         */

-        #if  defined(__MACH__) && !defined(__APPLE_CC__)

-                #include <libkern/OSByteOrder.h>

-                #define __cpu_to_be64(x) = OSSwapHostToBigInt64(x)

-                #define __cpu_to_be32(x) = OSSwapHostToBigInt32(x)

-

-                #define AIRCRACK_NG_BYTE_ORDER_DEFINED

-

-        #endif

-

-

-        // FreeBSD

-        #ifdef __FreeBSD__

-                #include <machine/endian.h>

-        #endif

-

-        // XXX: Is there anything to include on OpenBSD/NetBSD/DragonFlyBSD/...?

-

-

-        // XXX: Mac: Check http://www.opensource.apple.com/source/CF/CF-476.18/CFByteOrder.h

-        //           http://developer.apple.com/DOCUMENTATION/CoreFoundation/Reference/CFByteOrderUtils/Reference/reference.html

-        //           Write to apple to ask what should be used.

-

-        #if defined(LITTLE_ENDIAN)

-                #define AIRCRACK_NG_LITTLE_ENDIAN LITTLE_ENDIAN

-        #elif defined(__LITTLE_ENDIAN)

-                #define AIRCRACK_NG_LITTLE_ENDIAN __LITTLE_ENDIAN

-        #elif defined(_LITTLE_ENDIAN)

-                #define AIRCRACK_NG_LITTLE_ENDIAN _LITTLE_ENDIAN

-        #endif

-

-        #if defined(BIG_ENDIAN)

-                #define AIRCRACK_NG_BIG_ENDIAN BIG_ENDIAN

-        #elif defined(__BIG_ENDIAN)

-                #define AIRCRACK_NG_BIG_ENDIAN __BIG_ENDIAN

-        #elif defined(_BIG_ENDIAN)

-                #define AIRCRACK_NG_BIG_ENDIAN _BIG_ENDIAN

-        #endif

-

-        #if !defined(AIRCRACK_NG_LITTLE_ENDIAN) && !defined(AIRCRACK_NG_BIG_ENDIAN)

-                #error Impossible to determine endianness (Little or Big endian), please contact the author.

-        #endif

-

-        #if defined(BYTE_ORDER)

-                #if (BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

-                        #define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN

-                #elif (BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

-                        #define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN

-                #endif

-        #elif defined(__BYTE_ORDER)

-                #if (__BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

-                        #define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN

-                #elif (__BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

-                        #define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN

-                #endif

-        #elif defined(_BYTE_ORDER)

-                #if (_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

-                        #define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN

-                #elif (_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

-                        #define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN

-                #endif

-        #endif

-

-        #ifndef AIRCRACK_NG_BYTE_ORDER

-                #error Impossible to determine endianness (Little or Big endian), please contact the author.

-        #endif

-

-        #if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

-

-                #ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED

-                        #define __be64_to_cpu(x) ___my_swab64(x)

-                        #define __be32_to_cpu(x) ___my_swab32(x)

-                        #define __be16_to_cpu(x) ___my_swab16(x)

-                        #define __cpu_to_be64(x) ___my_swab64(x)

-                        #define __cpu_to_be32(x) ___my_swab32(x)

-                        #define __cpu_to_be16(x) ___my_swab16(x)

-                        #define __le64_to_cpu(x) (x)

-                        #define __le32_to_cpu(x) (x)

-                        #define __le16_to_cpu(x) (x)

-                        #define __cpu_to_le64(x) (x)

-                        #define __cpu_to_le32(x) (x)

-                        #define __cpu_to_le16(x) (x)

-                #endif

-

-                #ifndef htobe16

-                        #define htobe16 ___my_swab16

-                #endif

-                #ifndef htobe32

-                        #define htobe32 ___my_swab32

-                #endif

-                #ifndef betoh16

-                        #define betoh16 ___my_swab16

-                #endif

-                #ifndef betoh32

-                        #define betoh32 ___my_swab32

-                #endif

-

-                #ifndef htole16

-                        #define htole16(x) (x)

-                #endif

-                #ifndef htole32

-                        #define htole32(x) (x)

-                #endif

-                #ifndef letoh16

-                        #define letoh16(x) (x)

-                #endif

-                #ifndef letoh32

-                        #define letoh32(x) (x)

-                #endif

-

-        #endif

-

-        #if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

-

-                #ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED

-                        #define __be64_to_cpu(x) (x)

-                        #define __be32_to_cpu(x) (x)

-                        #define __be16_to_cpu(x) (x)

-                        #define __cpu_to_be64(x) (x)

-                        #define __cpu_to_be32(x) (x)

-                        #define __cpu_to_be16(x) (x)

-                        #define __le64_to_cpu(x) ___my_swab64(x)

-                        #define __le32_to_cpu(x) ___my_swab32(x)

-                        #define __le16_to_cpu(x) ___my_swab16(x)

-                        #define __cpu_to_le64(x) ___my_swab64(x)

-                        #define __cpu_to_le32(x) ___my_swab32(x)

-                        #define __cpu_to_le16(x) ___my_swab16(x)

-                #endif

-

-                #ifndef htobe16

-                        #define htobe16(x) (x)

-                #endif

-                #ifndef htobe32

-                        #define htobe32(x) (x)

-                #endif

-                #ifndef betoh16

-                        #define betoh16(x) (x)

-                #endif

-                #ifndef betoh32

-                        #define betoh32(x) (x)

-                #endif

-

-                #ifndef htole16

-                        #define htole16 ___my_swab16

-                #endif

-                #ifndef htole32

-                        #define htole32 ___my_swab32

-                #endif

-                #ifndef letoh16

-                        #define letoh16 ___my_swab16

-                #endif

-                #ifndef letoh32

-                        #define letoh32 ___my_swab32

-                #endif

-

-        #endif

-

-        // Common defines

-        #define cpu_to_le64 __cpu_to_le64

-        #define le64_to_cpu __le64_to_cpu

-        #define cpu_to_le32 __cpu_to_le32

-        #define le32_to_cpu __le32_to_cpu

-        #define cpu_to_le16 __cpu_to_le16

-        #define le16_to_cpu __le16_to_cpu

-        #define cpu_to_be64 __cpu_to_be64

-        #define be64_to_cpu __be64_to_cpu

-        #define cpu_to_be32 __cpu_to_be32

-        #define be32_to_cpu __be32_to_cpu

-        #define cpu_to_be16 __cpu_to_be16

-        #define be16_to_cpu __be16_to_cpu

-

-        #ifndef le16toh

-                #define le16toh le16_to_cpu

-        #endif

-        #ifndef be16toh

-                #define be16toh be16_to_cpu

-        #endif

-        #ifndef le32toh

-                #define le32toh le32_to_cpu

-        #endif

-        #ifndef be32toh

-                #define be32toh be32_to_cpu

-        #endif

-

-

-        #ifndef htons

-                #define htons be16_to_cpu

-        #endif

-        #ifndef htonl

-                #define htonl cpu_to_be16

-        #endif

-        #ifndef ntohs

-                #define ntohs cpu_to_be16

-        #endif

-        #ifndef ntohl

-                #define ntohl cpu_to_be32

-        #endif

-

-#endif

+#if __BYTE_ORDER == __LITTLE_ENDIAN

+#define htobe16(x) ___my_swab16 (x)

+#define htole16(x) (x)

+#define be16toh(x) ___my_swab16 (x)

+#define le16toh(x) (x)

+    

+#define htobe32(x) ___my_swab32 (x)

+#define htole32(x) (x)

+#define be32toh(x) ___my_swab32 (x)

+#define le32toh(x) (x)

+    

+#define htobe64(x) ___my_swab64 (x)

+#define htole64(x) (x)

+#define be64toh(x) ___my_swab64 (x)

+#define le64toh(x) (x)

+#else /* 
 */
+#define htobe16(x) (x)

+#define htole16(x) ___my_swab16 (x)

+#define be16toh(x) (x)

+#define le16toh(x) ___my_swab16 (x)

+    

+#define htobe32(x) (x)

+#define htole32(x) ___my_swab32 (x)

+#define be32toh(x) (x)

+#define le32toh(x) ___my_swab32 (x)

+    

+#define htobe64(x) (x)

+#define htole64(x) ___my_swab64 (x)

+#define be64toh(x) (x)

+#define le64toh(x) ___my_swab64 (x)

+#endif /* 
 */
+#endif /* 
 */
+    
 
 

+#endif /* 
 */
+    

+    /*

+     * Cygwin

+     */ 

+#if defined(__CYGWIN32__)

+#include <asm/byteorder.h>

+#include <unistd.h>

+    

+#define __be64_to_cpu(x) ___my_swab64(x)

+#define __be32_to_cpu(x) ___my_swab32(x)

+#define __be16_to_cpu(x) ___my_swab16(x)

+#define __cpu_to_be64(x) ___my_swab64(x)

+#define __cpu_to_be32(x) ___my_swab32(x)

+#define __cpu_to_be16(x) ___my_swab16(x)

+#define __le64_to_cpu(x) (x)

+#define __le32_to_cpu(x) (x)

+#define __le16_to_cpu(x) (x)

+#define __cpu_to_le64(x) (x)

+#define __cpu_to_le32(x) (x)

+#define __cpu_to_le16(x) (x)

+    

+#define AIRCRACK_NG_BYTE_ORDER_DEFINED

+    

+#endif /* 
 */
+    

+    /*

+     * Windows (DDK)

+     */ 

+#if defined(__WIN__)

+    

+#include <io.h>

+    

+#define __be64_to_cpu(x) ___my_swab64(x)

+#define __be32_to_cpu(x) ___my_swab32(x)

+#define __be16_to_cpu(x) ___my_swab16(x)

+#define __cpu_to_be64(x) ___my_swab64(x)

+#define __cpu_to_be32(x) ___my_swab32(x)

+#define __cpu_to_be16(x) ___my_swab16(x)

+#define __le64_to_cpu(x) (x)

+#define __le32_to_cpu(x) (x)

+#define __le16_to_cpu(x) (x)

+#define __cpu_to_le64(x) (x)

+#define __cpu_to_le32(x) (x)

+#define __cpu_to_le16(x) (x)

+    

+#define AIRCRACK_NG_BYTE_ORDER_DEFINED

+    

+#endif /* 
 */
+    

+    /*

+     * MAC (Darwin)

+     */ 

+#if defined(__APPLE_CC__)

+#if defined(__x86_64__) && defined(__APPLE__)

+    

+#include <libkern/OSByteOrder.h>

+    

+#define __swab64(x)      (unsigned long long) OSSwapInt64((uint64_t)x)

+#define __swab32(x)      (unsigned long) OSSwapInt32((uint32_t)x)

+#define __swab16(x)      (unsigned short) OSSwapInt16((uint16_t)x)

+#define __be64_to_cpu(x) (unsigned long long) OSSwapBigToHostInt64((uint64_t)x)

+#define __be32_to_cpu(x) (unsigned long) OSSwapBigToHostInt32((uint32_t)x)

+#define __be16_to_cpu(x) (unsigned short) OSSwapBigToHostInt16((uint16_t)x)

+#define __le64_to_cpu(x) (unsigned long long) OSSwapLittleToHostInt64((uint64_t)x)

+#define __le32_to_cpu(x) (unsigned long) OSSwapLittleToHostInt32((uint32_t)x)

+#define __le16_to_cpu(x) (unsigned short) OSSwapLittleToHostInt16((uint16_t)x)

+#define __cpu_to_be64(x) (unsigned long long) OSSwapHostToBigInt64((uint64_t)x)

+#define __cpu_to_be32(x) (unsigned long) OSSwapHostToBigInt32((uint32_t)x)

+#define __cpu_to_be16(x) (unsigned short) OSSwapHostToBigInt16((uint16_t)x)

+#define __cpu_to_le64(x) (unsigned long long) OSSwapHostToLittleInt64((uint64_t)x)

+#define __cpu_to_le32(x) (unsigned long) OSSwapHostToLittleInt32((uint32_t)x)

+#define __cpu_to_le16(x) (unsigned short) OSSwapHostToLittleInt16((uint16_t)x)

+    

+#else /* 
 */
+    

+#include <architecture/byte_order.h>

+    

+#define __swab64(x)      NXSwapLongLong(x)

+#define __swab32(x)      NXSwapLong(x)

+#define __swab16(x)      NXSwapShort(x)

+#define __be64_to_cpu(x) NXSwapBigLongLongToHost(x)

+#define __be32_to_cpu(x) NXSwapBigLongToHost(x)

+#define __be16_to_cpu(x) NXSwapBigShortToHost(x)

+#define __le64_to_cpu(x) NXSwapLittleLongLongToHost(x)

+#define __le32_to_cpu(x) NXSwapLittleLongToHost(x)

+#define __le16_to_cpu(x) NXSwapLittleShortToHost(x)

+#define __cpu_to_be64(x) NXSwapHostLongLongToBig(x)

+#define __cpu_to_be32(x) NXSwapHostLongToBig(x)

+#define __cpu_to_be16(x) NXSwapHostShortToBig(x)

+#define __cpu_to_le64(x) NXSwapHostLongLongToLittle(x)

+#define __cpu_to_le32(x) NXSwapHostLongToLittle(x)

+#define __cpu_to_le16(x) NXSwapHostShortToLittle(x)

+    

+#endif /* 
 */
+    

+#define __LITTLE_ENDIAN 1234

+#define __BIG_ENDIAN    4321

+#define __PDP_ENDIAN    3412

+#define __BYTE_ORDER    __BIG_ENDIAN

+    

+#define AIRCRACK_NG_BYTE_ORDER_DEFINED

+    

+#endif /* 
 */
+    

+    /*

+     * Solaris

+     * -------

+     */ 

+#if defined(__sparc__) && defined(__sun__)

+#include <sys/byteorder.h>

+#include <sys/types.h>

+#include <unistd.h>

+    

+#define __be64_to_cpu(x) (x)

+#define __be32_to_cpu(x) (x)

+#define __be16_to_cpu(x) (x)

+#define __cpu_to_be64(x) (x)

+#define __cpu_to_be32(x) (x)

+#define __cpu_to_be16(x) (x)

+#define __le64_to_cpu(x) ___my_swab64(x)

+#define __le32_to_cpu(x) ___my_swab32(x)

+#define __le16_to_cpu(x) ___my_swab16(x)

+#define __cpu_to_le64(x) ___my_swab64(x)

+#define __cpu_to_le32(x) ___my_swab32(x)

+#define __cpu_to_le16(x) ___my_swab16(x)

+
typedef uint64_t u_int64_t;
+
typedef uint32_t u_int32_t;
+
typedef uint16_t u_int16_t;
+
typedef uint8_t u_int8_t;
+
+
 

+#define AIRCRACK_NG_BYTE_ORDER_DEFINED

+    

+#endif /* 
 */
+    

+    /*

+     * Custom stuff

+     */ 

+#if  defined(__MACH__) && !defined(__APPLE_CC__)

+#include <libkern/OSByteOrder.h>

+#define __cpu_to_be64(x) = OSSwapHostToBigInt64(x)

+#define __cpu_to_be32(x) = OSSwapHostToBigInt32(x)

+    

+#define AIRCRACK_NG_BYTE_ORDER_DEFINED

+    

+#endif /* 
 */
+    
 

+    // FreeBSD

+#ifdef __FreeBSD__

+#include <machine/endian.h>

+#endif /* 
 */
+    

+    // XXX: Is there anything to include on OpenBSD/NetBSD/DragonFlyBSD/...?

+    
 

+    // XXX: Mac: Check http://www.opensource.apple.com/source/CF/CF-476.18/CFByteOrder.h

+    //           http://developer.apple.com/DOCUMENTATION/CoreFoundation/Reference/CFByteOrderUtils/Reference/reference.html

+    //           Write to apple to ask what should be used.

+    

+#if defined(LITTLE_ENDIAN)

+#define AIRCRACK_NG_LITTLE_ENDIAN LITTLE_ENDIAN

+#elif defined(__LITTLE_ENDIAN)

+#define AIRCRACK_NG_LITTLE_ENDIAN __LITTLE_ENDIAN

+#elif defined(_LITTLE_ENDIAN)

+#define AIRCRACK_NG_LITTLE_ENDIAN _LITTLE_ENDIAN

+#endif /* 
 */
+    

+#if defined(BIG_ENDIAN)

+#define AIRCRACK_NG_BIG_ENDIAN BIG_ENDIAN

+#elif defined(__BIG_ENDIAN)

+#define AIRCRACK_NG_BIG_ENDIAN __BIG_ENDIAN

+#elif defined(_BIG_ENDIAN)

+#define AIRCRACK_NG_BIG_ENDIAN _BIG_ENDIAN

+#endif /* 
 */
+    

+#if !defined(AIRCRACK_NG_LITTLE_ENDIAN) && !defined(AIRCRACK_NG_BIG_ENDIAN)

+#error Impossible to determine endianness (Little or Big endian), please contact the author.

+#endif /* 
 */
+    

+#if defined(BYTE_ORDER)

+#if (BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

+#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN

+#elif (BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

+#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN

+#endif /* 
 */
+#elif defined(__BYTE_ORDER)

+#if (__BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

+#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN

+#elif (__BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

+#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN

+#endif /* 
 */
+#elif defined(_BYTE_ORDER)

+#if (_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

+#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN

+#elif (_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

+#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN

+#endif /* 
 */
+#endif /* 
 */
+    

+#ifndef AIRCRACK_NG_BYTE_ORDER

+#error Impossible to determine endianness (Little or Big endian), please contact the author.

+#endif /* 
 */
+    

+#if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)

+    

+#ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED

+#define __be64_to_cpu(x) ___my_swab64(x)

+#define __be32_to_cpu(x) ___my_swab32(x)

+#define __be16_to_cpu(x) ___my_swab16(x)

+#define __cpu_to_be64(x) ___my_swab64(x)

+#define __cpu_to_be32(x) ___my_swab32(x)

+#define __cpu_to_be16(x) ___my_swab16(x)

+#define __le64_to_cpu(x) (x)

+#define __le32_to_cpu(x) (x)

+#define __le16_to_cpu(x) (x)

+#define __cpu_to_le64(x) (x)

+#define __cpu_to_le32(x) (x)

+#define __cpu_to_le16(x) (x)

+#endif /* 
 */
+    

+#ifndef htobe16

+#define htobe16 ___my_swab16

+#endif /* 
 */
+#ifndef htobe32

+#define htobe32 ___my_swab32

+#endif /* 
 */
+#ifndef betoh16

+#define betoh16 ___my_swab16

+#endif /* 
 */
+#ifndef betoh32

+#define betoh32 ___my_swab32

+#endif /* 
 */
+    

+#ifndef htole16

+#define htole16(x) (x)

+#endif /* 
 */
+#ifndef htole32

+#define htole32(x) (x)

+#endif /* 
 */
+#ifndef letoh16

+#define letoh16(x) (x)

+#endif /* 
 */
+#ifndef letoh32

+#define letoh32(x) (x)

+#endif /* 
 */
+    

+#endif /* 
 */
+    

+#if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)

+    

+#ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED

+#define __be64_to_cpu(x) (x)

+#define __be32_to_cpu(x) (x)

+#define __be16_to_cpu(x) (x)

+#define __cpu_to_be64(x) (x)

+#define __cpu_to_be32(x) (x)

+#define __cpu_to_be16(x) (x)

+#define __le64_to_cpu(x) ___my_swab64(x)

+#define __le32_to_cpu(x) ___my_swab32(x)

+#define __le16_to_cpu(x) ___my_swab16(x)

+#define __cpu_to_le64(x) ___my_swab64(x)

+#define __cpu_to_le32(x) ___my_swab32(x)

+#define __cpu_to_le16(x) ___my_swab16(x)

+#endif /* 
 */
+    

+#ifndef htobe16

+#define htobe16(x) (x)

+#endif /* 
 */
+#ifndef htobe32

+#define htobe32(x) (x)

+#endif /* 
 */
+#ifndef betoh16

+#define betoh16(x) (x)

+#endif /* 
 */
+#ifndef betoh32

+#define betoh32(x) (x)

+#endif /* 
 */
+    

+#ifndef htole16

+#define htole16 ___my_swab16

+#endif /* 
 */
+#ifndef htole32

+#define htole32 ___my_swab32

+#endif /* 
 */
+#ifndef letoh16

+#define letoh16 ___my_swab16

+#endif /* 
 */
+#ifndef letoh32

+#define letoh32 ___my_swab32

+#endif /* 
 */
+    

+#endif /* 
 */
+    

+    // Common defines

+#define cpu_to_le64 __cpu_to_le64

+#define le64_to_cpu __le64_to_cpu

+#define cpu_to_le32 __cpu_to_le32

+#define le32_to_cpu __le32_to_cpu

+#define cpu_to_le16 __cpu_to_le16

+#define le16_to_cpu __le16_to_cpu

+#define cpu_to_be64 __cpu_to_be64

+#define be64_to_cpu __be64_to_cpu

+#define cpu_to_be32 __cpu_to_be32

+#define be32_to_cpu __be32_to_cpu

+#define cpu_to_be16 __cpu_to_be16

+#define be16_to_cpu __be16_to_cpu

+    

+#ifndef le16toh

+#define le16toh le16_to_cpu

+#endif /* 
 */
+#ifndef be16toh

+#define be16toh be16_to_cpu

+#endif /* 
 */
+#ifndef le32toh

+#define le32toh le32_to_cpu

+#endif /* 
 */
+#ifndef be32toh

+#define be32toh be32_to_cpu

+#endif /* 
 */
+    
 

+#ifndef htons

+#define htons be16_to_cpu

+#endif /* 
 */
+#ifndef htonl

+#define htonl cpu_to_be16

+#endif /* 
 */
+#ifndef ntohs

+#define ntohs cpu_to_be16

+#endif /* 
 */
+#ifndef ntohl

+#define ntohl cpu_to_be32

+#endif /* 
 */
+    

+#endif /* 
 */
diff --git a/src/transport/wlan/crctable_osdep.h b/src/transport/wlan/crctable_osdep.h
index 4f14d245b..04c769f2a 100644
--- a/src/transport/wlan/crctable_osdep.h
+++ b/src/transport/wlan/crctable_osdep.h
@@ -1,40 +1,71 @@
 #ifndef _CRCTABLE_OSDEP_H
 #define _CRCTABLE_OSDEP_H
 
-const unsigned long int crc_tbl_osdep[256] =
-{
-    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
-    0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
-    0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
-    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
-    0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
-    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
-    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
-    0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
-    0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
-    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
-    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
-    0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
-    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
-    0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
-    0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
-    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
-    0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
-    0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
-    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
-    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
-    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
-    0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
-    0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
-    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
-    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
-    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
-    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
-    0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
-    0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
-    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
-    0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+const unsigned long int crc_tbl_osdep[256] = {
+  0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
+  0xE963A535, 0x9E6495A3,
+  0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
+  0xE7B82D07, 0x90BF1D91,
+  0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB,
+  0xF4D4B551, 0x83D385C7,
+  0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+  0xFA0F3D63, 0x8D080DF5,
+  0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447,
+  0xD20D85FD, 0xA50AB56B,
+  0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75,
+  0xDCD60DCF, 0xABD13D59,
+  0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+  0xCFBA9599, 0xB8BDA50F,
+  0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11,
+  0xC1611DAB, 0xB6662D3D,
+  0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
+  0x9FBFE4A5, 0xE8B8D433,
+  0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
+  0x91646C97, 0xE6635C01,
+  0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B,
+  0x8208F4C1, 0xF50FC457,
+  0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49,
+  0x8CD37CF3, 0xFBD44C65,
+  0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
+  0xA4D1C46D, 0xD3D6F4FB,
+  0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
+  0xAA0A4C5F, 0xDD0D7CC9,
+  0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3,
+  0xB966D409, 0xCE61E49F,
+  0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
+  0xB7BD5C3B, 0xC0BA6CAD,
+  0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF,
+  0x04DB2615, 0x73DC1683,
+  0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D,
+  0x0A00AE27, 0x7D079EB1,
+  0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+  0x196C3671, 0x6E6B06E7,
+  0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9,
+  0x17B7BE43, 0x60B08ED5,
+  0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767,
+  0x3FB506DD, 0x48B2364B,
+  0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
+  0x316E8EEF, 0x4669BE79,
+  0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
+  0x220216B9, 0x5505262F,
+  0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
+  0x2CD99E8B, 0x5BDEAE1D,
+  0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
+  0x72076785, 0x05005713,
+  0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D,
+  0x7CDCEFB7, 0x0BDBDF21,
+  0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B,
+  0x6FB077E1, 0x18B74777,
+  0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
+  0x616BFFD3, 0x166CCF45,
+  0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
+  0x4969474D, 0x3E6E77DB,
+  0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
+  0x47B2CF7F, 0x30B5FFE9,
+  0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
+  0x54DE5729, 0x23D967BF,
+  0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1,
+  0x5A05DF1B, 0x2D02EF8D
 };
 
 #endif /* crctable_osdep.h */
diff --git a/src/transport/wlan/helper_common.c b/src/transport/wlan/helper_common.c
index 24782ed11..d4b1204f6 100644
--- a/src/transport/wlan/helper_common.c
+++ b/src/transport/wlan/helper_common.c
@@ -34,17 +34,17 @@
  * @return number of bytes written
  */
 int
-send_mac_to_plugin(char * buffer, uint8_t * mac)
+send_mac_to_plugin (char *buffer, uint8_t * mac)
 {
 
   struct Wlan_Helper_Control_Message macmsg;
 
-  memcpy(macmsg.mac.mac, mac, sizeof(struct MacAddress));
-  macmsg.hdr.size = htons(sizeof(struct Wlan_Helper_Control_Message));
-  macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
+  memcpy (macmsg.mac.mac, mac, sizeof (struct MacAddress));
+  macmsg.hdr.size = htons (sizeof (struct Wlan_Helper_Control_Message));
+  macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL);
 
-  memcpy(buffer, &macmsg, sizeof(struct Wlan_Helper_Control_Message));
-  return sizeof(struct Wlan_Helper_Control_Message);
+  memcpy (buffer, &macmsg, sizeof (struct Wlan_Helper_Control_Message));
+  return sizeof (struct Wlan_Helper_Control_Message);
 }
 
 /*
@@ -70,40 +70,54 @@ send_mac_to_plugin(char * buffer, uint8_t * mac)
 /**
  * Return the frequency in Mhz from a channel number
  */
-int getFrequencyFromChannel(int channel)
+int
+getFrequencyFromChannel (int channel)
 {
-        static int frequencies[] = {
-                -1, // No channel 0
-                2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
-                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Nothing from channel 15 to 34 (exclusive)
-                5170, 5175, 5180, 5185, 5190, 5195, 5200, 5205, 5210, 5215, 5220, 5225, 5230, 5235, 5240, 5245,
-                5250, 5255, 5260, 5265, 5270, 5275, 5280, 5285, 5290, 5295, 5300, 5305, 5310, 5315, 5320, 5325,
-                5330, 5335, 5340, 5345, 5350, 5355, 5360, 5365, 5370, 5375, 5380, 5385, 5390, 5395, 5400, 5405,
-                5410, 5415, 5420, 5425, 5430, 5435, 5440, 5445, 5450, 5455, 5460, 5465, 5470, 5475, 5480, 5485,
-                5490, 5495, 5500, 5505, 5510, 5515, 5520, 5525, 5530, 5535, 5540, 5545, 5550, 5555, 5560, 5565,
-                5570, 5575, 5580, 5585, 5590, 5595, 5600, 5605, 5610, 5615, 5620, 5625, 5630, 5635, 5640, 5645,
-                5650, 5655, 5660, 5665, 5670, 5675, 5680, 5685, 5690, 5695, 5700, 5705, 5710, 5715, 5720, 5725,
-                5730, 5735, 5740, 5745, 5750, 5755, 5760, 5765, 5770, 5775, 5780, 5785, 5790, 5795, 5800, 5805,
-                5810, 5815, 5820, 5825, 5830, 5835, 5840, 5845, 5850, 5855, 5860, 5865, 5870, 5875, 5880, 5885,
-                5890, 5895, 5900, 5905, 5910, 5915, 5920, 5925, 5930, 5935, 5940, 5945, 5950, 5955, 5960, 5965,
-                5970, 5975, 5980, 5985, 5990, 5995, 6000, 6005, 6010, 6015, 6020, 6025, 6030, 6035, 6040, 6045,
-                6050, 6055, 6060, 6065, 6070, 6075, 6080, 6085, 6090, 6095, 6100
-        };
+  static int frequencies[] = {
+    -1,                         // No channel 0
+    2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467,
+    2472, 2484,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Nothing from channel 15 to 34 (exclusive)
+    5170, 5175, 5180, 5185, 5190, 5195, 5200, 5205, 5210, 5215, 5220, 5225,
+    5230, 5235, 5240, 5245,
+    5250, 5255, 5260, 5265, 5270, 5275, 5280, 5285, 5290, 5295, 5300, 5305,
+    5310, 5315, 5320, 5325,
+    5330, 5335, 5340, 5345, 5350, 5355, 5360, 5365, 5370, 5375, 5380, 5385,
+    5390, 5395, 5400, 5405,
+    5410, 5415, 5420, 5425, 5430, 5435, 5440, 5445, 5450, 5455, 5460, 5465,
+    5470, 5475, 5480, 5485,
+    5490, 5495, 5500, 5505, 5510, 5515, 5520, 5525, 5530, 5535, 5540, 5545,
+    5550, 5555, 5560, 5565,
+    5570, 5575, 5580, 5585, 5590, 5595, 5600, 5605, 5610, 5615, 5620, 5625,
+    5630, 5635, 5640, 5645,
+    5650, 5655, 5660, 5665, 5670, 5675, 5680, 5685, 5690, 5695, 5700, 5705,
+    5710, 5715, 5720, 5725,
+    5730, 5735, 5740, 5745, 5750, 5755, 5760, 5765, 5770, 5775, 5780, 5785,
+    5790, 5795, 5800, 5805,
+    5810, 5815, 5820, 5825, 5830, 5835, 5840, 5845, 5850, 5855, 5860, 5865,
+    5870, 5875, 5880, 5885,
+    5890, 5895, 5900, 5905, 5910, 5915, 5920, 5925, 5930, 5935, 5940, 5945,
+    5950, 5955, 5960, 5965,
+    5970, 5975, 5980, 5985, 5990, 5995, 6000, 6005, 6010, 6015, 6020, 6025,
+    6030, 6035, 6040, 6045,
+    6050, 6055, 6060, 6065, 6070, 6075, 6080, 6085, 6090, 6095, 6100
+  };
 
-        return (channel > 0 && channel <= 221) ? frequencies[channel] : -1;
+  return (channel > 0 && channel <= 221) ? frequencies[channel] : -1;
 }
 
 /**
  * Return the channel from the frequency (in Mhz)
  */
-int getChannelFromFrequency(int frequency)
+int
+getChannelFromFrequency (int frequency)
 {
-        if (frequency >= 2412 && frequency <= 2472)
-                return (frequency - 2407) / 5;
-        else if (frequency == 2484)
-                return 14;
-        else if (frequency >= 5000 && frequency <= 6100)
-                return (frequency - 5000) / 5;
-        else
-                return -1;
+  if (frequency >= 2412 && frequency <= 2472)
+    return (frequency - 2407) / 5;
+  else if (frequency == 2484)
+    return 14;
+  else if (frequency >= 5000 && frequency <= 6100)
+    return (frequency - 5000) / 5;
+  else
+    return -1;
 }
diff --git a/src/transport/wlan/helper_common.h b/src/transport/wlan/helper_common.h
index 71c3e1b9b..550ebda6f 100644
--- a/src/transport/wlan/helper_common.h
+++ b/src/transport/wlan/helper_common.h
@@ -8,8 +8,8 @@
 #ifndef HELPER_COMMON_H_
 #define HELPER_COMMON_H_
 
-int getFrequencyFromChannel(int channel);
-int getChannelFromFrequency(int frequency);
-int send_mac_to_plugin(char * buffer, uint8_t * mac);
+int getFrequencyFromChannel (int channel);
+int getChannelFromFrequency (int frequency);
+int send_mac_to_plugin (char *buffer, uint8_t * mac);
 
 #endif /* HELPER_COMMON_H_ */
diff --git a/src/transport/wlan/ieee80211.h b/src/transport/wlan/ieee80211.h
index 8df1d2c29..a952674ca 100644
--- a/src/transport/wlan/ieee80211.h
+++ b/src/transport/wlan/ieee80211.h
@@ -38,72 +38,78 @@
  * 802.11 protocol definitions.
  */
 
-#define IEEE80211_ADDR_LEN      6               /* size of 802.11 address */
+#define IEEE80211_ADDR_LEN      6       /* size of 802.11 address */
 /* is 802.11 address multicast/broadcast? */
 #define IEEE80211_IS_MULTICAST(_a)      (*(_a) & 0x01)
 
 /* IEEE 802.11 PLCP header */
-struct ieee80211_plcp_hdr {
-        u_int16_t       i_sfd;
-        u_int8_t        i_signal;
-        u_int8_t        i_service;
-        u_int16_t       i_length;
-        u_int16_t       i_crc;
+struct ieee80211_plcp_hdr
+{
+  u_int16_t i_sfd;
+  u_int8_t i_signal;
+  u_int8_t i_service;
+  u_int16_t i_length;
+  u_int16_t i_crc;
 } GNUNET_PACKED;
 
-#define IEEE80211_PLCP_SFD      0xF3A0 
+#define IEEE80211_PLCP_SFD      0xF3A0
 #define IEEE80211_PLCP_SERVICE  0x00
 
 /*
  * generic definitions for IEEE 802.11 frames
  */
-struct ieee80211_frame {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_addr1[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr2[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr3[IEEE80211_ADDR_LEN];
-        u_int8_t        i_seq[2];
-        /* possibly followed by addr4[IEEE80211_ADDR_LEN]; */
-        /* see below */
+struct ieee80211_frame
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_addr1[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr2[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr3[IEEE80211_ADDR_LEN];
+  u_int8_t i_seq[2];
+  /* possibly followed by addr4[IEEE80211_ADDR_LEN]; */
+  /* see below */
 } GNUNET_PACKED;
 
-struct ieee80211_qosframe {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_addr1[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr2[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr3[IEEE80211_ADDR_LEN];
-        u_int8_t        i_seq[2];
-        u_int8_t        i_qos[2];
-        /* possibly followed by addr4[IEEE80211_ADDR_LEN]; */
-        /* see below */
+struct ieee80211_qosframe
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_addr1[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr2[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr3[IEEE80211_ADDR_LEN];
+  u_int8_t i_seq[2];
+  u_int8_t i_qos[2];
+  /* possibly followed by addr4[IEEE80211_ADDR_LEN]; */
+  /* see below */
 } GNUNET_PACKED;
 
-struct ieee80211_qoscntl {
-        u_int8_t        i_qos[2];
+struct ieee80211_qoscntl
+{
+  u_int8_t i_qos[2];
 };
 
-struct ieee80211_frame_addr4 {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_addr1[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr2[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr3[IEEE80211_ADDR_LEN];
-        u_int8_t        i_seq[2];
-        u_int8_t        i_addr4[IEEE80211_ADDR_LEN];
+struct ieee80211_frame_addr4
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_addr1[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr2[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr3[IEEE80211_ADDR_LEN];
+  u_int8_t i_seq[2];
+  u_int8_t i_addr4[IEEE80211_ADDR_LEN];
 } GNUNET_PACKED;
 
 
-struct ieee80211_qosframe_addr4 {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_addr1[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr2[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr3[IEEE80211_ADDR_LEN];
-        u_int8_t        i_seq[2];
-        u_int8_t        i_addr4[IEEE80211_ADDR_LEN];
-        u_int8_t        i_qos[2];
+struct ieee80211_qosframe_addr4
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_addr1[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr2[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr3[IEEE80211_ADDR_LEN];
+  u_int8_t i_seq[2];
+  u_int8_t i_addr4[IEEE80211_ADDR_LEN];
+  u_int8_t i_qos[2];
 } GNUNET_PACKED;
 
 #define IEEE80211_FC0_VERSION_MASK              0x03
@@ -149,10 +155,10 @@ struct ieee80211_qosframe_addr4 {
 #define IEEE80211_FC0_SUBTYPE_QOS_NULL          0xc0
 
 #define IEEE80211_FC1_DIR_MASK                  0x03
-#define IEEE80211_FC1_DIR_NODS                  0x00    /* STA->STA */
-#define IEEE80211_FC1_DIR_TODS                  0x01    /* STA->AP  */
-#define IEEE80211_FC1_DIR_FROMDS                0x02    /* AP ->STA */
-#define IEEE80211_FC1_DIR_DSTODS                0x03    /* AP ->AP  */
+#define IEEE80211_FC1_DIR_NODS                  0x00    /* STA->STA */
+#define IEEE80211_FC1_DIR_TODS                  0x01    /* STA->AP  */
+#define IEEE80211_FC1_DIR_FROMDS                0x02    /* AP ->STA */
+#define IEEE80211_FC1_DIR_DSTODS                0x03    /* AP ->AP  */
 
 #define IEEE80211_FC1_MORE_FRAG                 0x04
 #define IEEE80211_FC1_RETRY                     0x08
@@ -185,65 +191,68 @@ struct ieee80211_qosframe_addr4 {
 /*
  * WME/802.11e information element.
  */
-struct ieee80211_wme_info {
-        u_int8_t        wme_id;         /* IEEE80211_ELEMID_VENDOR */
-        u_int8_t        wme_len;        /* length in bytes */
-        u_int8_t        wme_oui[3];     /* 0x00, 0x50, 0xf2 */
-        u_int8_t        wme_type;       /* OUI type */
-        u_int8_t        wme_subtype;    /* OUI subtype */
-        u_int8_t        wme_version;    /* spec revision */
-        u_int8_t        wme_info;       /* QoS info */
+struct ieee80211_wme_info
+{
+  u_int8_t wme_id;              /* IEEE80211_ELEMID_VENDOR */
+  u_int8_t wme_len;             /* length in bytes */
+  u_int8_t wme_oui[3];          /* 0x00, 0x50, 0xf2 */
+  u_int8_t wme_type;            /* OUI type */
+  u_int8_t wme_subtype;         /* OUI subtype */
+  u_int8_t wme_version;         /* spec revision */
+  u_int8_t wme_info;            /* QoS info */
 } GNUNET_PACKED;
 
 /*
  * WME/802.11e Tspec Element
  */
-struct ieee80211_wme_tspec {
-        u_int8_t        ts_id;
-        u_int8_t        ts_len;
-        u_int8_t        ts_oui[3];
-        u_int8_t        ts_oui_type;
-        u_int8_t        ts_oui_subtype;
-        u_int8_t        ts_version;
-        u_int8_t        ts_tsinfo[3];
-        u_int8_t        ts_nom_msdu[2];
-        u_int8_t        ts_max_msdu[2];
-        u_int8_t        ts_min_svc[4];
-        u_int8_t        ts_max_svc[4];
-        u_int8_t        ts_inactv_intv[4];
-        u_int8_t        ts_susp_intv[4];
-        u_int8_t        ts_start_svc[4];
-        u_int8_t        ts_min_rate[4];
-        u_int8_t        ts_mean_rate[4];
-        u_int8_t        ts_max_burst[4];
-        u_int8_t        ts_min_phy[4];
-        u_int8_t        ts_peak_rate[4];
-        u_int8_t        ts_delay[4];
-        u_int8_t        ts_surplus[2];
-        u_int8_t        ts_medium_time[2];
+struct ieee80211_wme_tspec
+{
+  u_int8_t ts_id;
+  u_int8_t ts_len;
+  u_int8_t ts_oui[3];
+  u_int8_t ts_oui_type;
+  u_int8_t ts_oui_subtype;
+  u_int8_t ts_version;
+  u_int8_t ts_tsinfo[3];
+  u_int8_t ts_nom_msdu[2];
+  u_int8_t ts_max_msdu[2];
+  u_int8_t ts_min_svc[4];
+  u_int8_t ts_max_svc[4];
+  u_int8_t ts_inactv_intv[4];
+  u_int8_t ts_susp_intv[4];
+  u_int8_t ts_start_svc[4];
+  u_int8_t ts_min_rate[4];
+  u_int8_t ts_mean_rate[4];
+  u_int8_t ts_max_burst[4];
+  u_int8_t ts_min_phy[4];
+  u_int8_t ts_peak_rate[4];
+  u_int8_t ts_delay[4];
+  u_int8_t ts_surplus[2];
+  u_int8_t ts_medium_time[2];
 } GNUNET_PACKED;
 
 /*
  * WME AC parameter field
  */
-struct ieee80211_wme_acparams {
-        u_int8_t        acp_aci_aifsn;
-        u_int8_t        acp_logcwminmax;
-        u_int16_t       acp_txop;
+struct ieee80211_wme_acparams
+{
+  u_int8_t acp_aci_aifsn;
+  u_int8_t acp_logcwminmax;
+  u_int16_t acp_txop;
 } GNUNET_PACKED;
 
-#define WME_NUM_AC              4       /* 4 AC categories */
+#define WME_NUM_AC              4       /* 4 AC categories */
 
-#define WME_PARAM_ACI           0x60    /* Mask for ACI field */
-#define WME_PARAM_ACI_S         5       /* Shift for ACI field */
-#define WME_PARAM_ACM           0x10    /* Mask for ACM bit */
-#define WME_PARAM_ACM_S         4       /* Shift for ACM bit */
-#define WME_PARAM_AIFSN         0x0f    /* Mask for aifsn field */
-#define WME_PARAM_AIFSN_S       0       /* Shift for aifsn field */
-#define WME_PARAM_LOGCWMIN      0x0f    /* Mask for CwMin field (in log) */
-#define WME_PARAM_LOGCWMIN_S    0       /* Shift for CwMin field */
-#define WME_PARAM_LOGCWMAX      0xf0    /* Mask for CwMax field (in log) */
-#define WME_PARAM_LOGCWMAX_S    4       /* Shift for CwMax field */
+#define WME_PARAM_ACI           0x60    /* Mask for ACI field */
+#define WME_PARAM_ACI_S         5       /* Shift for ACI field */
+#define WME_PARAM_ACM           0x10    /* Mask for ACM bit */
+#define WME_PARAM_ACM_S         4       /* Shift for ACM bit */
+#define WME_PARAM_AIFSN         0x0f    /* Mask for aifsn field */
+#define WME_PARAM_AIFSN_S       0       /* Shift for aifsn field */
+#define WME_PARAM_LOGCWMIN      0x0f    /* Mask for CwMin field (in log) */
+#define WME_PARAM_LOGCWMIN_S    0       /* Shift for CwMin field */
+#define WME_PARAM_LOGCWMAX      0xf0    /* Mask for CwMax field (in log) */
+#define WME_PARAM_LOGCWMAX_S    4       /* Shift for CwMax field */
 
 #define WME_AC_TO_TID(_ac) (       \
         ((_ac) == WME_AC_VO) ? 6 : \
@@ -260,28 +269,31 @@ struct ieee80211_wme_acparams {
 /*
  * WME Parameter Element
  */
-struct ieee80211_wme_param {
-        u_int8_t        param_id;
-        u_int8_t        param_len;
-        u_int8_t        param_oui[3];
-        u_int8_t        param_oui_type;
-        u_int8_t        param_oui_sybtype;
-        u_int8_t        param_version;
-        u_int8_t        param_qosInfo;
-#define WME_QOSINFO_COUNT       0x0f    /* Mask for param count field */
-        u_int8_t        param_reserved;
-        struct ieee80211_wme_acparams   params_acParams[WME_NUM_AC];
+struct ieee80211_wme_param
+{
+  u_int8_t param_id;
+  u_int8_t param_len;
+  u_int8_t param_oui[3];
+  u_int8_t param_oui_type;
+  u_int8_t param_oui_sybtype;
+  u_int8_t param_version;
+  u_int8_t param_qosInfo;
+#define WME_QOSINFO_COUNT       0x0f    /* Mask for param count field */
+  u_int8_t param_reserved;
+  struct ieee80211_wme_acparams params_acParams[WME_NUM_AC];
 } GNUNET_PACKED;
 
 /*
  * Management Notification Frame
  */
-struct ieee80211_mnf {
-        u_int8_t        mnf_category;
-        u_int8_t        mnf_action;
-        u_int8_t        mnf_dialog;
-        u_int8_t        mnf_status;
+struct ieee80211_mnf
+{
+  u_int8_t mnf_category;
+  u_int8_t mnf_action;
+  u_int8_t mnf_dialog;
+  u_int8_t mnf_status;
 } GNUNET_PACKED;
+
 #define MNF_SETUP_REQ   0
 #define MNF_SETUP_RESP  1
 #define MNF_TEARDOWN    2
@@ -289,50 +301,56 @@ struct ieee80211_mnf {
 /*
  * Control frames.
  */
-struct ieee80211_frame_min {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_addr1[IEEE80211_ADDR_LEN];
-        u_int8_t        i_addr2[IEEE80211_ADDR_LEN];
-        /* FCS */
+struct ieee80211_frame_min
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_addr1[IEEE80211_ADDR_LEN];
+  u_int8_t i_addr2[IEEE80211_ADDR_LEN];
+  /* FCS */
 } GNUNET_PACKED;
 
-struct ieee80211_frame_rts {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_ra[IEEE80211_ADDR_LEN];
-        u_int8_t        i_ta[IEEE80211_ADDR_LEN];
-        /* FCS */
+struct ieee80211_frame_rts
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_ra[IEEE80211_ADDR_LEN];
+  u_int8_t i_ta[IEEE80211_ADDR_LEN];
+  /* FCS */
 } GNUNET_PACKED;
 
-struct ieee80211_frame_cts {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_ra[IEEE80211_ADDR_LEN];
-        /* FCS */
+struct ieee80211_frame_cts
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_ra[IEEE80211_ADDR_LEN];
+  /* FCS */
 } GNUNET_PACKED;
 
-struct ieee80211_frame_ack {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];
-        u_int8_t        i_ra[IEEE80211_ADDR_LEN];
-        /* FCS */
+struct ieee80211_frame_ack
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];
+  u_int8_t i_ra[IEEE80211_ADDR_LEN];
+  /* FCS */
 } GNUNET_PACKED;
 
-struct ieee80211_frame_pspoll {
-        u_int8_t        i_fc[2];
-        u_int8_t        i_aid[2];
-        u_int8_t        i_bssid[IEEE80211_ADDR_LEN];
-        u_int8_t        i_ta[IEEE80211_ADDR_LEN];
-        /* FCS */
+struct ieee80211_frame_pspoll
+{
+  u_int8_t i_fc[2];
+  u_int8_t i_aid[2];
+  u_int8_t i_bssid[IEEE80211_ADDR_LEN];
+  u_int8_t i_ta[IEEE80211_ADDR_LEN];
+  /* FCS */
 } GNUNET_PACKED;
 
-struct ieee80211_frame_cfend {          /* NB: also CF-End+CF-Ack */
-        u_int8_t        i_fc[2];
-        u_int8_t        i_dur[2];       /* should be zero */
-        u_int8_t        i_ra[IEEE80211_ADDR_LEN];
-        u_int8_t        i_bssid[IEEE80211_ADDR_LEN];
-        /* FCS */
+struct ieee80211_frame_cfend
+{                               /* NB: also CF-End+CF-Ack */
+  u_int8_t i_fc[2];
+  u_int8_t i_dur[2];            /* should be zero */
+  u_int8_t i_ra[IEEE80211_ADDR_LEN];
+  u_int8_t i_bssid[IEEE80211_ADDR_LEN];
+  /* FCS */
 } GNUNET_PACKED;
 
 /*
@@ -372,63 +390,68 @@ typedef u_int8_t *ieee80211_mgt_beacon_t;
 /*
  * 802.11i/WPA information element (maximally sized).
  */
-struct ieee80211_ie_wpa {
-        u_int8_t        wpa_id;         /* IEEE80211_ELEMID_VENDOR */
-        u_int8_t        wpa_len;        /* length in bytes */
-        u_int8_t        wpa_oui[3];     /* 0x00, 0x50, 0xf2 */
-        u_int8_t        wpa_type;       /* OUI type */
-        u_int16_t       wpa_version;    /* spec revision */
-        u_int32_t       wpa_mcipher[1]; /* multicast/group key cipher */
-        u_int16_t       wpa_uciphercnt; /* # pairwise key ciphers */
-        u_int32_t       wpa_uciphers[8];/* ciphers */
-        u_int16_t       wpa_authselcnt; /* authentication selector cnt*/
-        u_int32_t       wpa_authsels[8];/* selectors */
-        u_int16_t       wpa_caps;       /* 802.11i capabilities */
-        u_int16_t       wpa_pmkidcnt;   /* 802.11i pmkid count */
-        u_int16_t       wpa_pmkids[8];  /* 802.11i pmkids */
+struct ieee80211_ie_wpa
+{
+  u_int8_t wpa_id;              /* IEEE80211_ELEMID_VENDOR */
+  u_int8_t wpa_len;             /* length in bytes */
+  u_int8_t wpa_oui[3];          /* 0x00, 0x50, 0xf2 */
+  u_int8_t wpa_type;            /* OUI type */
+  u_int16_t wpa_version;        /* spec revision */
+  u_int32_t wpa_mcipher[1];     /* multicast/group key cipher */
+  u_int16_t wpa_uciphercnt;     /* # pairwise key ciphers */
+  u_int32_t wpa_uciphers[8];    /* ciphers */
+  u_int16_t wpa_authselcnt;     /* authentication selector cnt */
+  u_int32_t wpa_authsels[8];    /* selectors */
+  u_int16_t wpa_caps;           /* 802.11i capabilities */
+  u_int16_t wpa_pmkidcnt;       /* 802.11i pmkid count */
+  u_int16_t wpa_pmkids[8];      /* 802.11i pmkids */
 } GNUNET_PACKED;
 
 /*
  * Management information element payloads.
  */
 
-enum {
-        IEEE80211_ELEMID_SSID           = 0,
-        IEEE80211_ELEMID_RATES          = 1,
-        IEEE80211_ELEMID_FHPARMS        = 2,
-        IEEE80211_ELEMID_DSPARMS        = 3,
-        IEEE80211_ELEMID_CFPARMS        = 4,
-        IEEE80211_ELEMID_TIM            = 5,
-        IEEE80211_ELEMID_IBSSPARMS      = 6,
-        IEEE80211_ELEMID_COUNTRY        = 7,
-        IEEE80211_ELEMID_CHALLENGE      = 16,
-        /* 17-31 reserved for challenge text extension */
-        IEEE80211_ELEMID_ERP            = 42,
-        IEEE80211_ELEMID_RSN            = 48,
-        IEEE80211_ELEMID_XRATES         = 50,
-        IEEE80211_ELEMID_TPC            = 150,
-        IEEE80211_ELEMID_CCKM           = 156,
-        IEEE80211_ELEMID_VENDOR         = 221,  /* vendor private */
+enum
+{
+  IEEE80211_ELEMID_SSID = 0,
+  IEEE80211_ELEMID_RATES = 1,
+  IEEE80211_ELEMID_FHPARMS = 2,
+  IEEE80211_ELEMID_DSPARMS = 3,
+  IEEE80211_ELEMID_CFPARMS = 4,
+  IEEE80211_ELEMID_TIM = 5,
+  IEEE80211_ELEMID_IBSSPARMS = 6,
+  IEEE80211_ELEMID_COUNTRY = 7,
+  IEEE80211_ELEMID_CHALLENGE = 16,
+  /* 17-31 reserved for challenge text extension */
+  IEEE80211_ELEMID_ERP = 42,
+  IEEE80211_ELEMID_RSN = 48,
+  IEEE80211_ELEMID_XRATES = 50,
+  IEEE80211_ELEMID_TPC = 150,
+  IEEE80211_ELEMID_CCKM = 156,
+  IEEE80211_ELEMID_VENDOR = 221,        /* vendor private */
 };
 
-struct ieee80211_tim_ie {
-        u_int8_t        tim_ie;                 /* IEEE80211_ELEMID_TIM */
-        u_int8_t        tim_len;
-        u_int8_t        tim_count;              /* DTIM count */
-        u_int8_t        tim_period;             /* DTIM period */
-        u_int8_t        tim_bitctl;             /* bitmap control */
-        u_int8_t        tim_bitmap[1];          /* variable-length bitmap */
+struct ieee80211_tim_ie
+{
+  u_int8_t tim_ie;              /* IEEE80211_ELEMID_TIM */
+  u_int8_t tim_len;
+  u_int8_t tim_count;           /* DTIM count */
+  u_int8_t tim_period;          /* DTIM period */
+  u_int8_t tim_bitctl;          /* bitmap control */
+  u_int8_t tim_bitmap[1];       /* variable-length bitmap */
 } GNUNET_PACKED;
 
-struct ieee80211_country_ie {
-        u_int8_t        ie;                     /* IEEE80211_ELEMID_COUNTRY */
-        u_int8_t        len;
-        u_int8_t        cc[3];                  /* ISO CC+(I)ndoor/(O)utdoor */
-        struct {
-                u_int8_t schan;                 /* starting channel */
-                u_int8_t nchan;                 /* number channels */
-                u_int8_t maxtxpwr;              /* tx power cap */
-        } GNUNET_PACKED band[4];                        /* up to 4 sub bands */
+struct ieee80211_country_ie
+{
+  u_int8_t ie;                  /* IEEE80211_ELEMID_COUNTRY */
+  u_int8_t len;
+  u_int8_t cc[3];               /* ISO CC+(I)ndoor/(O)utdoor */
+  struct
+  {
+    u_int8_t schan;             /* starting channel */
+    u_int8_t nchan;             /* number channels */
+    u_int8_t maxtxpwr;          /* tx power cap */
+  } GNUNET_PACKED band[4];      /* up to 4 sub bands */
 } GNUNET_PACKED;
 
 #define IEEE80211_CHALLENGE_LEN         128
@@ -448,13 +471,13 @@ struct ieee80211_country_ie {
 /* bits 3-6 reserved */
 #define ATHEROS_CAP_BOOST               0x80
 
-#define ATH_OUI                 0x7f0300                /* Atheros OUI */
+#define ATH_OUI                 0x7f0300        /* Atheros OUI */
 #define ATH_OUI_TYPE            0x01
 #define ATH_OUI_VERSION         0x01
 
 #define WPA_OUI                 0xf25000
 #define WPA_OUI_TYPE            0x01
-#define WPA_VERSION             1               /* current supported version */
+#define WPA_VERSION             1       /* current supported version */
 
 #define WPA_CSE_NULL            0x00
 #define WPA_CSE_WEP40           0x01
@@ -467,7 +490,7 @@ struct ieee80211_country_ie {
 #define WPA_ASE_8021X_PSK       0x02
 
 #define RSN_OUI                 0xac0f00
-#define RSN_VERSION             1               /* current supported version */
+#define RSN_VERSION             1       /* current supported version */
 
 #define RSN_CSE_NULL            0x00
 #define RSN_CSE_WEP40           0x01
@@ -489,10 +512,10 @@ struct ieee80211_country_ie {
 #define WME_VERSION             1
 
 /* WME stream classes */
-#define WME_AC_BE       0               /* best effort */
-#define WME_AC_BK       1               /* background */
-#define WME_AC_VI       2               /* video */
-#define WME_AC_VO       3               /* voice */
+#define WME_AC_BE       0       /* best effort */
+#define WME_AC_BK       1       /* background */
+#define WME_AC_VI       2       /* video */
+#define WME_AC_VO       3       /* voice */
 
 /*
  * AUTH management packets
@@ -518,16 +541,18 @@ typedef u_int8_t *ieee80211_mgt_auth_t;
 #define IEEE80211_AUTH_ALG_SHARED       0x0001
 #define IEEE80211_AUTH_ALG_LEAP         0x0080
 
-enum {
-        IEEE80211_AUTH_OPEN_REQUEST             = 1,
-        IEEE80211_AUTH_OPEN_RESPONSE            = 2,
+enum
+{
+  IEEE80211_AUTH_OPEN_REQUEST = 1,
+  IEEE80211_AUTH_OPEN_RESPONSE = 2,
 };
 
-enum {
-        IEEE80211_AUTH_SHARED_REQUEST           = 1,
-        IEEE80211_AUTH_SHARED_CHALLENGE         = 2,
-        IEEE80211_AUTH_SHARED_RESPONSE          = 3,
-        IEEE80211_AUTH_SHARED_PASS              = 4,
+enum
+{
+  IEEE80211_AUTH_SHARED_REQUEST = 1,
+  IEEE80211_AUTH_SHARED_CHALLENGE = 2,
+  IEEE80211_AUTH_SHARED_RESPONSE = 3,
+  IEEE80211_AUTH_SHARED_PASS = 4,
 };
 
 /*
@@ -536,47 +561,48 @@ enum {
  * Unlisted codes are reserved
  */
 
-enum {
-        IEEE80211_REASON_UNSPECIFIED            = 1,
-        IEEE80211_REASON_AUTH_EXPIRE            = 2,
-        IEEE80211_REASON_AUTH_LEAVE             = 3,
-        IEEE80211_REASON_ASSOC_EXPIRE           = 4,
-        IEEE80211_REASON_ASSOC_TOOMANY          = 5,
-        IEEE80211_REASON_NOT_AUTHED             = 6,
-        IEEE80211_REASON_NOT_ASSOCED            = 7,
-        IEEE80211_REASON_ASSOC_LEAVE            = 8,
-        IEEE80211_REASON_ASSOC_NOT_AUTHED       = 9,
-
-        IEEE80211_REASON_RSN_REQUIRED           = 11,
-        IEEE80211_REASON_RSN_INCONSISTENT       = 12,
-        IEEE80211_REASON_IE_INVALID             = 13,
-        IEEE80211_REASON_MIC_FAILURE            = 14,
-
-        IEEE80211_STATUS_SUCCESS                = 0,
-        IEEE80211_STATUS_UNSPECIFIED            = 1,
-        IEEE80211_STATUS_CAPINFO                = 10,
-        IEEE80211_STATUS_NOT_ASSOCED            = 11,
-        IEEE80211_STATUS_OTHER                  = 12,
-        IEEE80211_STATUS_ALG                    = 13,
-        IEEE80211_STATUS_SEQUENCE               = 14,
-        IEEE80211_STATUS_CHALLENGE              = 15,
-        IEEE80211_STATUS_TIMEOUT                = 16,
-        IEEE80211_STATUS_TOOMANY                = 17,
-        IEEE80211_STATUS_BASIC_RATE             = 18,
-        IEEE80211_STATUS_SP_REQUIRED            = 19,
-        IEEE80211_STATUS_PBCC_REQUIRED          = 20,
-        IEEE80211_STATUS_CA_REQUIRED            = 21,
-        IEEE80211_STATUS_TOO_MANY_STATIONS      = 22,
-        IEEE80211_STATUS_RATES                  = 23,
-        IEEE80211_STATUS_SHORTSLOT_REQUIRED     = 25,
-        IEEE80211_STATUS_DSSSOFDM_REQUIRED      = 26,
+enum
+{
+  IEEE80211_REASON_UNSPECIFIED = 1,
+  IEEE80211_REASON_AUTH_EXPIRE = 2,
+  IEEE80211_REASON_AUTH_LEAVE = 3,
+  IEEE80211_REASON_ASSOC_EXPIRE = 4,
+  IEEE80211_REASON_ASSOC_TOOMANY = 5,
+  IEEE80211_REASON_NOT_AUTHED = 6,
+  IEEE80211_REASON_NOT_ASSOCED = 7,
+  IEEE80211_REASON_ASSOC_LEAVE = 8,
+  IEEE80211_REASON_ASSOC_NOT_AUTHED = 9,
+
+  IEEE80211_REASON_RSN_REQUIRED = 11,
+  IEEE80211_REASON_RSN_INCONSISTENT = 12,
+  IEEE80211_REASON_IE_INVALID = 13,
+  IEEE80211_REASON_MIC_FAILURE = 14,
+
+  IEEE80211_STATUS_SUCCESS = 0,
+  IEEE80211_STATUS_UNSPECIFIED = 1,
+  IEEE80211_STATUS_CAPINFO = 10,
+  IEEE80211_STATUS_NOT_ASSOCED = 11,
+  IEEE80211_STATUS_OTHER = 12,
+  IEEE80211_STATUS_ALG = 13,
+  IEEE80211_STATUS_SEQUENCE = 14,
+  IEEE80211_STATUS_CHALLENGE = 15,
+  IEEE80211_STATUS_TIMEOUT = 16,
+  IEEE80211_STATUS_TOOMANY = 17,
+  IEEE80211_STATUS_BASIC_RATE = 18,
+  IEEE80211_STATUS_SP_REQUIRED = 19,
+  IEEE80211_STATUS_PBCC_REQUIRED = 20,
+  IEEE80211_STATUS_CA_REQUIRED = 21,
+  IEEE80211_STATUS_TOO_MANY_STATIONS = 22,
+  IEEE80211_STATUS_RATES = 23,
+  IEEE80211_STATUS_SHORTSLOT_REQUIRED = 25,
+  IEEE80211_STATUS_DSSSOFDM_REQUIRED = 26,
 };
 
-#define IEEE80211_WEP_KEYLEN            5       /* 40bit */
-#define IEEE80211_WEP_IVLEN             3       /* 24bit */
-#define IEEE80211_WEP_KIDLEN            1       /* 1 octet */
-#define IEEE80211_WEP_CRCLEN            4       /* CRC-32 */
-#define IEEE80211_WEP_NKID              4       /* number of key ids */
+#define IEEE80211_WEP_KEYLEN            5       /* 40bit */
+#define IEEE80211_WEP_IVLEN             3       /* 24bit */
+#define IEEE80211_WEP_KIDLEN            1       /* 1 octet */
+#define IEEE80211_WEP_CRCLEN            4       /* CRC-32 */
+#define IEEE80211_WEP_NKID              4       /* number of key ids */
 
 /*
  * 802.11i defines an extended IV for use with non-WEP ciphers.
@@ -586,8 +612,8 @@ enum {
  * CCMP header rather than IV+extended-IV.
  */
 #define IEEE80211_WEP_EXTIV             0x20
-#define IEEE80211_WEP_EXTIVLEN          4       /* extended IV length */
-#define IEEE80211_WEP_MICLEN            8       /* trailing MIC */
+#define IEEE80211_WEP_EXTIVLEN          4       /* extended IV length */
+#define IEEE80211_WEP_MICLEN            8       /* trailing MIC */
 
 #define IEEE80211_CRC_LEN               4
 
@@ -641,16 +667,16 @@ enum {
  * As above, we treat default as implementation-dependent so
  * define it elsewhere.
  */
-#define IEEE80211_BINTVAL_MAX   1000    /* max beacon interval (TU's) */
-#define IEEE80211_BINTVAL_MIN   25      /* min beacon interval (TU's) */
+#define IEEE80211_BINTVAL_MAX   1000    /* max beacon interval (TU's) */
+#define IEEE80211_BINTVAL_MIN   25      /* min beacon interval (TU's) */
 
 /*
  * DTIM period (beacons).  Min+max are not really defined
  * by the protocol but we want them publicly visible so
  * define them here.
  */
-#define IEEE80211_DTIM_MAX      15      /* max DTIM period */
-#define IEEE80211_DTIM_MIN      1       /* min DTIM period */
+#define IEEE80211_DTIM_MAX      15      /* max DTIM period */
+#define IEEE80211_DTIM_MIN      1       /* min DTIM period */
 
 /*
  * Beacon miss threshold (beacons).  As for DTIM, we define
diff --git a/src/transport/wlan/ieee80211_radiotap.h b/src/transport/wlan/ieee80211_radiotap.h
index b132d402d..f3afbecce 100644
--- a/src/transport/wlan/ieee80211_radiotap.h
+++ b/src/transport/wlan/ieee80211_radiotap.h
@@ -66,25 +66,26 @@
 /* The radio capture header precedes the 802.11 header.
  * All data in the header is little endian on all platforms.
  */
-struct ieee80211_radiotap_header {
-        u8 it_version;          /* Version 0. Only increases
-                                 * for drastic changes,
-                                 * introduction of compatible
-                                 * new fields does not count.
-                                 */
-        u8 it_pad;
-        u16 it_len;             /* length of the whole
-                                 * header in bytes, including
-                                 * it_version, it_pad,
-                                 * it_len, and data fields.
-                                 */
-        u32 it_present;         /* A bitmap telling which
-                                 * fields are present. Set bit 31
-                                 * (0x80000000) to extend the
-                                 * bitmap by another 32 bits.
-                                 * Additional extensions are made
-                                 * by setting bit 31.
-                                 */
+struct ieee80211_radiotap_header
+{
+  u8 it_version;                /* Version 0. Only increases
+                                 * for drastic changes,
+                                 * introduction of compatible
+                                 * new fields does not count.
+                                 */
+  u8 it_pad;
+  u16 it_len;                   /* length of the whole
+                                 * header in bytes, including
+                                 * it_version, it_pad,
+                                 * it_len, and data fields.
+                                 */
+  u32 it_present;               /* A bitmap telling which
+                                 * fields are present. Set bit 31
+                                 * (0x80000000) to extend the
+                                 * bitmap by another 32 bits.
+                                 * Additional extensions are made
+                                 * by setting bit 31.
+                                 */
 };
 
 #define IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK 0x80000000
@@ -186,68 +187,69 @@ struct ieee80211_radiotap_header {
  *     Number of unicast retries a transmitted frame used.
  *
  */
-enum ieee80211_radiotap_type {
-        IEEE80211_RADIOTAP_TSFT = 0,
-        IEEE80211_RADIOTAP_FLAGS = 1,
-        IEEE80211_RADIOTAP_RATE = 2,
-        IEEE80211_RADIOTAP_CHANNEL = 3,
-        IEEE80211_RADIOTAP_FHSS = 4,
-        IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
-        IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
-        IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
-        IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
-        IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
-        IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
-        IEEE80211_RADIOTAP_ANTENNA = 11,
-        IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
-        IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
-        IEEE80211_RADIOTAP_RX_FLAGS = 14,
-        IEEE80211_RADIOTAP_TX_FLAGS = 15,
-        IEEE80211_RADIOTAP_RTS_RETRIES = 16,
-        IEEE80211_RADIOTAP_DATA_RETRIES = 17,
-        IEEE80211_RADIOTAP_EXT = 31
+enum ieee80211_radiotap_type
+{
+  IEEE80211_RADIOTAP_TSFT = 0,
+  IEEE80211_RADIOTAP_FLAGS = 1,
+  IEEE80211_RADIOTAP_RATE = 2,
+  IEEE80211_RADIOTAP_CHANNEL = 3,
+  IEEE80211_RADIOTAP_FHSS = 4,
+  IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
+  IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
+  IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
+  IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
+  IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
+  IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
+  IEEE80211_RADIOTAP_ANTENNA = 11,
+  IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
+  IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
+  IEEE80211_RADIOTAP_RX_FLAGS = 14,
+  IEEE80211_RADIOTAP_TX_FLAGS = 15,
+  IEEE80211_RADIOTAP_RTS_RETRIES = 16,
+  IEEE80211_RADIOTAP_DATA_RETRIES = 17,
+  IEEE80211_RADIOTAP_EXT = 31
 };
 
 /* Channel flags. */
-#define IEEE80211_CHAN_TURBO    0x0010  /* Turbo channel */
-#define IEEE80211_CHAN_CCK      0x0020  /* CCK channel */
-#define IEEE80211_CHAN_OFDM     0x0040  /* OFDM channel */
-#define IEEE80211_CHAN_2GHZ     0x0080  /* 2 GHz spectrum channel. */
-#define IEEE80211_CHAN_5GHZ     0x0100  /* 5 GHz spectrum channel */
-#define IEEE80211_CHAN_PASSIVE  0x0200  /* Only passive scan allowed */
-#define IEEE80211_CHAN_DYN      0x0400  /* Dynamic CCK-OFDM channel */
-#define IEEE80211_CHAN_GFSK     0x0800  /* GFSK channel (FHSS PHY) */
+#define IEEE80211_CHAN_TURBO    0x0010  /* Turbo channel */
+#define IEEE80211_CHAN_CCK      0x0020  /* CCK channel */
+#define IEEE80211_CHAN_OFDM     0x0040  /* OFDM channel */
+#define IEEE80211_CHAN_2GHZ     0x0080  /* 2 GHz spectrum channel. */
+#define IEEE80211_CHAN_5GHZ     0x0100  /* 5 GHz spectrum channel */
+#define IEEE80211_CHAN_PASSIVE  0x0200  /* Only passive scan allowed */
+#define IEEE80211_CHAN_DYN      0x0400  /* Dynamic CCK-OFDM channel */
+#define IEEE80211_CHAN_GFSK     0x0800  /* GFSK channel (FHSS PHY) */
 
 /* For IEEE80211_RADIOTAP_FLAGS */
-#define IEEE80211_RADIOTAP_F_CFP        0x01    /* sent/received
-                                                 * during CFP
-                                                 */
-#define IEEE80211_RADIOTAP_F_SHORTPRE   0x02    /* sent/received
-                                                 * with short
-                                                 * preamble
-                                                 */
-#define IEEE80211_RADIOTAP_F_WEP        0x04    /* sent/received
-                                                 * with WEP encryption
-                                                 */
-#define IEEE80211_RADIOTAP_F_FRAG       0x08    /* sent/received
-                                                 * with fragmentation
-                                                 */
-#define IEEE80211_RADIOTAP_F_FCS        0x10    /* frame includes FCS */
-#define IEEE80211_RADIOTAP_F_DATAPAD    0x20    /* frame has padding between
-                                                 * 802.11 header and payload
-                                                 * (to 32-bit boundary)
-                                                 */
+#define IEEE80211_RADIOTAP_F_CFP        0x01    /* sent/received
+                                                 * during CFP
+                                                 */
+#define IEEE80211_RADIOTAP_F_SHORTPRE   0x02    /* sent/received
+                                                 * with short
+                                                 * preamble
+                                                 */
+#define IEEE80211_RADIOTAP_F_WEP        0x04    /* sent/received
+                                                 * with WEP encryption
+                                                 */
+#define IEEE80211_RADIOTAP_F_FRAG       0x08    /* sent/received
+                                                 * with fragmentation
+                                                 */
+#define IEEE80211_RADIOTAP_F_FCS        0x10    /* frame includes FCS */
+#define IEEE80211_RADIOTAP_F_DATAPAD    0x20    /* frame has padding between
+                                                 * 802.11 header and payload
+                                                 * (to 32-bit boundary)
+                                                 */
 /* For IEEE80211_RADIOTAP_RX_FLAGS */
-#define IEEE80211_RADIOTAP_F_RX_BADFCS  0x0001  /* frame failed crc check */
+#define IEEE80211_RADIOTAP_F_RX_BADFCS  0x0001  /* frame failed crc check */
 
 /* For IEEE80211_RADIOTAP_TX_FLAGS */
-#define IEEE80211_RADIOTAP_F_TX_FAIL    0x0001  /* failed due to excessive
-                                                 * retries */
-#define IEEE80211_RADIOTAP_F_TX_CTS     0x0002  /* used cts 'protection' */
-#define IEEE80211_RADIOTAP_F_TX_RTS     0x0004  /* used rts/cts handshake */
-#define IEEE80211_RADIOTAP_F_TX_NOACK   0x0008  /* frame should not be ACKed */
-#define IEEE80211_RADIOTAP_F_TX_NOSEQ   0x0010  /* sequence number handled
-                                                 * by userspace */
+#define IEEE80211_RADIOTAP_F_TX_FAIL    0x0001  /* failed due to excessive
+                                                 * retries */
+#define IEEE80211_RADIOTAP_F_TX_CTS     0x0002  /* used cts 'protection' */
+#define IEEE80211_RADIOTAP_F_TX_RTS     0x0004  /* used rts/cts handshake */
+#define IEEE80211_RADIOTAP_F_TX_NOACK   0x0008  /* frame should not be ACKed */
+#define IEEE80211_RADIOTAP_F_TX_NOSEQ   0x0010  /* sequence number handled
+                                                 * by userspace */
 
 /* Ugly macro to convert literal channel numbers into their mhz equivalents
  * There are certianly some conditions that will break this (like feeding it '30')
@@ -257,4 +259,4 @@ enum ieee80211_radiotap_type {
         (((x) == 14) ? 2484 : ((x) * 5) + 2407) : \
         ((x) + 1000) * 5)
 
-#endif                          /* IEEE80211_RADIOTAP_H */
+#endif /* IEEE80211_RADIOTAP_H */
diff --git a/src/transport/wlan/loopback_helper.h b/src/transport/wlan/loopback_helper.h
index 7c9fd5d07..d6afb1129 100644
--- a/src/transport/wlan/loopback_helper.h
+++ b/src/transport/wlan/loopback_helper.h
@@ -14,7 +14,6 @@
 
 //static void file_in_send(void *cls, void *client, const struct GNUNET_MessageHeader *hdr);
 
-int
-testmode(int argc, char *argv[]);
+int testmode (int argc, char *argv[]);
 
 #endif /* LOOPBACK_HELPER_H_ */
diff --git a/src/transport/wlan/radiotap-parser.c b/src/transport/wlan/radiotap-parser.c
index 46ea6d542..51dfd7107 100644
--- a/src/transport/wlan/radiotap-parser.c
+++ b/src/transport/wlan/radiotap-parser.c
@@ -38,67 +38,69 @@
  */
 
 
-int ieee80211_radiotap_iterator_init(
-        struct ieee80211_radiotap_iterator * iterator,
-        struct ieee80211_radiotap_header * radiotap_header,
-        int max_length)
+int
+ieee80211_radiotap_iterator_init (struct ieee80211_radiotap_iterator *iterator,
+                                  struct ieee80211_radiotap_header
+                                  *radiotap_header, int max_length)
 {
-        if(iterator == NULL)
-                return (-EINVAL);
+  if (iterator == NULL)
+    return (-EINVAL);
 
-        if(radiotap_header == NULL)
-                return (-EINVAL);
-        /* Linux only supports version 0 radiotap format */
+  if (radiotap_header == NULL)
+    return (-EINVAL);
+  /* Linux only supports version 0 radiotap format */
 
-        if (radiotap_header->it_version)
-                return (-EINVAL);
+  if (radiotap_header->it_version)
+    return (-EINVAL);
 
-        /* sanity check for allowed length and radiotap length field */
+  /* sanity check for allowed length and radiotap length field */
 
-        if (max_length < (le16_to_cpu(radiotap_header->it_len)))
-                return (-EINVAL);
+  if (max_length < (le16_to_cpu (radiotap_header->it_len)))
+    return (-EINVAL);
 
-        iterator->rtheader = radiotap_header;
-        iterator->max_length = le16_to_cpu(radiotap_header->it_len);
-        iterator->arg_index = 0;
-        iterator->bitmap_shifter = le32_to_cpu(radiotap_header->it_present);
-        iterator->arg = ((u8 *)radiotap_header) +
-                        sizeof (struct ieee80211_radiotap_header);
-        iterator->this_arg = 0;
+  iterator->rtheader = radiotap_header;
+  iterator->max_length = le16_to_cpu (radiotap_header->it_len);
+  iterator->arg_index = 0;
+  iterator->bitmap_shifter = le32_to_cpu (radiotap_header->it_present);
+  iterator->arg = ((u8 *) radiotap_header) +
+      sizeof (struct ieee80211_radiotap_header);
+  iterator->this_arg = 0;
 
-        /* find payload start allowing for extended bitmap(s) */
+  /* find payload start allowing for extended bitmap(s) */
 
-        if (unlikely(iterator->bitmap_shifter &
-            IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK)) {
-                while (le32_to_cpu(*((u32 *)iterator->arg)) &
-                    IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK) {
-                        iterator->arg += sizeof (u32);
+  if (unlikely (iterator->bitmap_shifter &
+                IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK))
+  {
+    while (le32_to_cpu (*((u32 *) iterator->arg)) &
+           IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK)
+    {
+      iterator->arg += sizeof (u32);
 
-                        /*
-                         * check for insanity where the present bitmaps
-                         * keep claiming to extend up to or even beyond the
-                         * stated radiotap header length
-                         */
+      /*
+       * check for insanity where the present bitmaps
+       * keep claiming to extend up to or even beyond the
+       * stated radiotap header length
+       */
 
-                        if ((((void*)iterator->arg) - ((void*)iterator->rtheader)) >
-                            iterator->max_length)
-                                return (-EINVAL);
+      if ((((void *) iterator->arg) - ((void *) iterator->rtheader)) >
+          iterator->max_length)
+        return (-EINVAL);
 
-                }
+    }
 
-                iterator->arg += sizeof (u32);
+    iterator->arg += sizeof (u32);
 
-                /*
-                 * no need to check again for blowing past stated radiotap
-                 * header length, becuase ieee80211_radiotap_iterator_next
-                 * checks it before it is dereferenced
-                 */
+    /*
+     * no need to check again for blowing past stated radiotap
+     * header length, becuase ieee80211_radiotap_iterator_next
+     * checks it before it is dereferenced
+     */
 
-        }
+  }
 
-        /* we are all initialized happily */
+  /* we are all initialized happily */
 
-        return (0);
+  return (0);
 }
 
 
@@ -115,137 +117,143 @@ int ieee80211_radiotap_iterator_init(
  * format.
  */
 
-int ieee80211_radiotap_iterator_next(
-        struct ieee80211_radiotap_iterator * iterator)
+int
+ieee80211_radiotap_iterator_next (struct ieee80211_radiotap_iterator *iterator)
 {
 
-        /*
-         * small length lookup table for all radiotap types we heard of
-         * starting from b0 in the bitmap, so we can walk the payload
-         * area of the radiotap header
-         *
-         * There is a requirement to pad args, so that args
-         * of a given length must begin at a boundary of that length
-         * -- but note that compound args are allowed (eg, 2 x u16
-         * for IEEE80211_RADIOTAP_CHANNEL) so total arg length is not
-         * a reliable indicator of alignment requirement.
-         *
-         * upper nybble: content alignment for arg
-         * lower nybble: content length for arg
-         */
-
-        static const u8 rt_sizes[] = {
-                [IEEE80211_RADIOTAP_TSFT] = 0x88,
-                [IEEE80211_RADIOTAP_FLAGS] = 0x11,
-                [IEEE80211_RADIOTAP_RATE] = 0x11,
-                [IEEE80211_RADIOTAP_CHANNEL] = 0x24,
-                [IEEE80211_RADIOTAP_FHSS] = 0x22,
-                [IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = 0x11,
-                [IEEE80211_RADIOTAP_DBM_ANTNOISE] = 0x11,
-                [IEEE80211_RADIOTAP_LOCK_QUALITY] = 0x22,
-                [IEEE80211_RADIOTAP_TX_ATTENUATION] = 0x22,
-                [IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = 0x22,
-                [IEEE80211_RADIOTAP_DBM_TX_POWER] = 0x11,
-                [IEEE80211_RADIOTAP_ANTENNA] = 0x11,
-                [IEEE80211_RADIOTAP_DB_ANTSIGNAL] = 0x11,
-                [IEEE80211_RADIOTAP_DB_ANTNOISE] = 0x11,
-                [IEEE80211_RADIOTAP_TX_FLAGS] = 0x22,
-                [IEEE80211_RADIOTAP_RX_FLAGS] = 0x22,
-                [IEEE80211_RADIOTAP_RTS_RETRIES] = 0x11,
-                [IEEE80211_RADIOTAP_DATA_RETRIES] = 0x11
-                /*
-                 * add more here as they are defined in
-                 * include/net/ieee80211_radiotap.h
-                 */
-        };
-
-        /*
-         * for every radiotap entry we can at
-         * least skip (by knowing the length)...
-         */
-
-        while (iterator->arg_index < (int)sizeof (rt_sizes)) {
-                int hit = 0;
-
-                if (!(iterator->bitmap_shifter & 1))
-                        goto next_entry; /* arg not present */
-
-                /*
-                 * arg is present, account for alignment padding
-                 *  8-bit args can be at any alignment
-                 * 16-bit args must start on 16-bit boundary
-                 * 32-bit args must start on 32-bit boundary
-                 * 64-bit args must start on 64-bit boundary
-                 *
-                 * note that total arg size can differ from alignment of
-                 * elements inside arg, so we use upper nybble of length
-                 * table to base alignment on
-                 *
-                 * also note: these alignments are ** relative to the
-                 * start of the radiotap header **.  There is no guarantee
-                 * that the radiotap header itself is aligned on any
-                 * kind of boundary.
-                 */
-
-                if ((((void*)iterator->arg)-((void*)iterator->rtheader)) &
-                    ((rt_sizes[iterator->arg_index] >> 4) - 1))
-                        iterator->arg_index +=
-                                (rt_sizes[iterator->arg_index] >> 4) -
-                                ((((void*)iterator->arg) -
-                                ((void*)iterator->rtheader)) &
-                                ((rt_sizes[iterator->arg_index] >> 4) - 1));
-
-                /*
-                 * this is what we will return to user, but we need to
-                 * move on first so next call has something fresh to test
-                 */
-
-                iterator->this_arg_index = iterator->arg_index;
-                iterator->this_arg = iterator->arg;
-                hit = 1;
-
-                /* internally move on the size of this arg */
-
-                iterator->arg += rt_sizes[iterator->arg_index] & 0x0f;
-
-                /*
-                 * check for insanity where we are given a bitmap that
-                 * claims to have more arg content than the length of the
-                 * radiotap section.  We will normally end up equalling this
-                 * max_length on the last arg, never exceeding it.
-                 */
-
-                if ((((void*)iterator->arg) - ((void*)iterator->rtheader)) >
-                    iterator->max_length)
-                        return (-EINVAL);
-
-        next_entry:
-
-                iterator->arg_index++;
-                if (unlikely((iterator->arg_index & 31) == 0)) {
-                        /* completed current u32 bitmap */
-                        if (iterator->bitmap_shifter & 1) {
-                                /* b31 was set, there is more */
-                                /* move to next u32 bitmap */
-                                iterator->bitmap_shifter = le32_to_cpu(
-                                        *iterator->next_bitmap);
-                                iterator->next_bitmap++;
-                        } else {
-                                /* no more bitmaps: end */
-                                iterator->arg_index = sizeof (rt_sizes);
-                        }
-                } else { /* just try the next bit */
-                        iterator->bitmap_shifter >>= 1;
-                }
-
-                /* if we found a valid arg earlier, return it now */
-
-                if (hit)
-                        return (iterator->this_arg_index);
-
-        }
-
-        /* we don't know how to handle any more args, we're done */
-
-        return (-1);
+  /*
+   * small length lookup table for all radiotap types we heard of
+   * starting from b0 in the bitmap, so we can walk the payload
+   * area of the radiotap header
+   *
+   * There is a requirement to pad args, so that args
+   * of a given length must begin at a boundary of that length
+   * -- but note that compound args are allowed (eg, 2 x u16
+   * for IEEE80211_RADIOTAP_CHANNEL) so total arg length is not
+   * a reliable indicator of alignment requirement.
+   *
+   * upper nybble: content alignment for arg
+   * lower nybble: content length for arg
+   */
+
+  static const u8 rt_sizes[] = {
+    [IEEE80211_RADIOTAP_TSFT] = 0x88,
+    [IEEE80211_RADIOTAP_FLAGS] = 0x11,
+    [IEEE80211_RADIOTAP_RATE] = 0x11,
+    [IEEE80211_RADIOTAP_CHANNEL] = 0x24,
+    [IEEE80211_RADIOTAP_FHSS] = 0x22,
+    [IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = 0x11,
+    [IEEE80211_RADIOTAP_DBM_ANTNOISE] = 0x11,
+    [IEEE80211_RADIOTAP_LOCK_QUALITY] = 0x22,
+    [IEEE80211_RADIOTAP_TX_ATTENUATION] = 0x22,
+    [IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = 0x22,
+    [IEEE80211_RADIOTAP_DBM_TX_POWER] = 0x11,
+    [IEEE80211_RADIOTAP_ANTENNA] = 0x11,
+    [IEEE80211_RADIOTAP_DB_ANTSIGNAL] = 0x11,
+    [IEEE80211_RADIOTAP_DB_ANTNOISE] = 0x11,
+    [IEEE80211_RADIOTAP_TX_FLAGS] = 0x22,
+    [IEEE80211_RADIOTAP_RX_FLAGS] = 0x22,
+    [IEEE80211_RADIOTAP_RTS_RETRIES] = 0x11,
+    [IEEE80211_RADIOTAP_DATA_RETRIES] = 0x11
+        /*
+         * add more here as they are defined in
+         * include/net/ieee80211_radiotap.h
+         */
+  };
+
+  /*
+   * for every radiotap entry we can at
+   * least skip (by knowing the length)...
+   */
+
+  while (iterator->arg_index < (int) sizeof (rt_sizes))
+  {
+    int hit = 0;
+
+    if (!(iterator->bitmap_shifter & 1))
+      goto next_entry;          /* arg not present */
+
+    /*
+     * arg is present, account for alignment padding
+     *  8-bit args can be at any alignment
+     * 16-bit args must start on 16-bit boundary
+     * 32-bit args must start on 32-bit boundary
+     * 64-bit args must start on 64-bit boundary
+     *
+     * note that total arg size can differ from alignment of
+     * elements inside arg, so we use upper nybble of length
+     * table to base alignment on
+     *
+     * also note: these alignments are ** relative to the
+     * start of the radiotap header **.  There is no guarantee
+     * that the radiotap header itself is aligned on any
+     * kind of boundary.
+     */
+
+    if ((((void *) iterator->arg) - ((void *) iterator->rtheader)) &
+        ((rt_sizes[iterator->arg_index] >> 4) - 1))
+      iterator->arg_index +=
+          (rt_sizes[iterator->arg_index] >> 4) -
+          ((((void *) iterator->arg) -
+            ((void *) iterator->rtheader)) &
+           ((rt_sizes[iterator->arg_index] >> 4) - 1));
+
+    /*
+     * this is what we will return to user, but we need to
+     * move on first so next call has something fresh to test
+     */
+
+    iterator->this_arg_index = iterator->arg_index;
+    iterator->this_arg = iterator->arg;
+    hit = 1;
+
+    /* internally move on the size of this arg */
+
+    iterator->arg += rt_sizes[iterator->arg_index] & 0x0f;
+
+    /*
+     * check for insanity where we are given a bitmap that
+     * claims to have more arg content than the length of the
+     * radiotap section.  We will normally end up equalling this
+     * max_length on the last arg, never exceeding it.
+     */
+
+    if ((((void *) iterator->arg) - ((void *) iterator->rtheader)) >
+        iterator->max_length)
+      return (-EINVAL);
+
+next_entry:
+
+    iterator->arg_index++;
+    if (unlikely ((iterator->arg_index & 31) == 0))
+    {
+      /* completed current u32 bitmap */
+      if (iterator->bitmap_shifter & 1)
+      {
+        /* b31 was set, there is more */
+        /* move to next u32 bitmap */
+        iterator->bitmap_shifter = le32_to_cpu (*iterator->next_bitmap);
+        iterator->next_bitmap++;
+      }
+      else
+      {
+        /* no more bitmaps: end */
+        iterator->arg_index = sizeof (rt_sizes);
+      }
+    }
+    else
+    {                           /* just try the next bit */
+      iterator->bitmap_shifter >>= 1;
+    }
+
+    /* if we found a valid arg earlier, return it now */
+
+    if (hit)
+      return (iterator->this_arg_index);
+
+  }
+
+  /* we don't know how to handle any more args, we're done */
+
+  return (-1);
 }
diff --git a/src/transport/wlan/radiotap-parser.h b/src/transport/wlan/radiotap-parser.h
index b36037369..fb6d8e2af 100644
--- a/src/transport/wlan/radiotap-parser.h
+++ b/src/transport/wlan/radiotap-parser.h
@@ -57,22 +57,23 @@ typedef uint8_t u8;
  * @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
  */
 
-struct ieee80211_radiotap_iterator {
-        struct ieee80211_radiotap_header *rtheader;
-        int max_length;
-        int this_arg_index;
-        u8 * this_arg;
+struct ieee80211_radiotap_iterator
+{
+  struct ieee80211_radiotap_header *rtheader;
+  int max_length;
+  int this_arg_index;
+  u8 *this_arg;
 
-        int arg_index;
-        u8 * arg;
-        u32 *next_bitmap;
-        u32 bitmap_shifter;
+  int arg_index;
+  u8 *arg;
+  u32 *next_bitmap;
+  u32 bitmap_shifter;
 };
 
-int ieee80211_radiotap_iterator_init(
-        struct ieee80211_radiotap_iterator * iterator,
-        struct ieee80211_radiotap_header * radiotap_header,
-        int max_length);
+int ieee80211_radiotap_iterator_init (struct ieee80211_radiotap_iterator
+                                      *iterator,
+                                      struct ieee80211_radiotap_header
+                                      *radiotap_header, int max_length);
 
-int ieee80211_radiotap_iterator_next(
-        struct ieee80211_radiotap_iterator * iterator);
+int ieee80211_radiotap_iterator_next (struct ieee80211_radiotap_iterator
+                                      *iterator);