1 files changed, 416 insertions, 410 deletions

diff --git a/src/transport/test_plugin_transport.c b/src/transport/test_plugin_transport.c
index 686938afc..ceb4333ac 100644
--- a/src/transport/test_plugin_transport.c
+++ b/src/transport/test_plugin_transport.c
@@ -36,8 +36,8 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define WAIT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
+#define WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
 #define HOSTKEY_FILE "test_plugin_hostkey.ecc"
 
@@ -89,12 +89,12 @@ struct GNUNET_HELPER_Handle *suid_helper;
 /**
  * Timeout task
  */
-static struct GNUNET_SCHEDULER_Task * timeout_endbadly;
+static struct GNUNET_SCHEDULER_Task *timeout_endbadly;
 
 /**
  * Timeout task
  */
-static struct GNUNET_SCHEDULER_Task * timeout_wait;
+static struct GNUNET_SCHEDULER_Task *timeout_wait;
 
 /**
  * Library name
@@ -120,7 +120,8 @@ unsigned int pretty_printers_running;
  */
 static int ok;
 
-struct AddressWrapper {
+struct AddressWrapper
+{
   struct AddressWrapper *next;
 
   struct AddressWrapper *prev;
@@ -134,7 +135,7 @@ struct AddressWrapper {
 
 
 static void
-end()
+end ()
 {
   struct AddressWrapper *w;
   int c = 0;
@@ -142,153 +143,154 @@ end()
   ok = 0;
 
   if (NULL != timeout_endbadly)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_endbadly);
-      timeout_endbadly = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_endbadly);
+    timeout_endbadly = NULL;
+  }
   if (NULL != api)
-    GNUNET_PLUGIN_unload(libname, api);
+    GNUNET_PLUGIN_unload (libname, api);
 
   while (NULL != head)
-    {
-      w = head;
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Plugin did not remove address `%s'\n",
-                 w->addrstring);
-      GNUNET_CONTAINER_DLL_remove(head, tail, w);
-      c++;
-      GNUNET_HELLO_address_free(w->address);
-      GNUNET_free(w->addrstring);
-      GNUNET_free(w);
-    }
+  {
+    w = head;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin did not remove address `%s'\n",
+                w->addrstring);
+    GNUNET_CONTAINER_DLL_remove (head, tail, w);
+    c++;
+    GNUNET_HELLO_address_free (w->address);
+    GNUNET_free (w->addrstring);
+    GNUNET_free (w);
+  }
   if (c > 0)
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove %u addresses \n",
-                 c);
-      ok = 1;
-    }
-
-  GNUNET_free(libname);
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin did not remove %u addresses \n",
+                c);
+    ok = 1;
+  }
+
+  GNUNET_free (libname);
   libname = NULL;
-  GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
+  GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
   stats = NULL;
 
   if (NULL != suid_helper)
-    {
-      GNUNET_HELPER_stop(suid_helper, GNUNET_NO);
-      suid_helper = NULL;
-    }
+  {
+    GNUNET_HELPER_stop (suid_helper, GNUNET_NO);
+    suid_helper = NULL;
+  }
 }
 
 
 static void
-end_badly(void *cls)
+end_badly (void *cls)
 {
   struct AddressWrapper *w;
   int c = 0;
 
   timeout_endbadly = NULL;
   if (NULL != timeout_wait)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_wait);
-      timeout_wait = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_wait);
+    timeout_wait = NULL;
+  }
 
   if (pretty_printers_running > 0)
-    {
-      timeout_endbadly = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
-                                                      &end_badly, &ok);
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Have pending calls to pretty_printer ... deferring shutdown\n");
-      return;
-    }
+  {
+    timeout_endbadly = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                                     &end_badly, &ok);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Have pending calls to pretty_printer ... deferring shutdown\n");
+    return;
+  }
 
   if (NULL != cls)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Test took too long to execute, timeout .... \n");
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Test took too long to execute, timeout .... \n");
+  }
 
   if (NULL != libname)
-    {
-      if (NULL != api)
-        GNUNET_PLUGIN_unload(libname, api);
-      GNUNET_free(libname);
-      libname = NULL;
-    }
+  {
+    if (NULL != api)
+      GNUNET_PLUGIN_unload (libname, api);
+    GNUNET_free (libname);
+    libname = NULL;
+  }
 
   while (NULL != head)
-    {
-      w = head;
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove address `%s'\n",
-                 w->addrstring);
-      GNUNET_CONTAINER_DLL_remove(head, tail, w);
-      c++;
-      GNUNET_HELLO_address_free(w->address);
-      if (NULL != w->test_task)
-        GNUNET_SCHEDULER_cancel(w->test_task);
-      GNUNET_free(w->addrstring);
-      GNUNET_free(w);
-    }
+  {
+    w = head;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove address `%s'\n",
+                w->addrstring);
+    GNUNET_CONTAINER_DLL_remove (head, tail, w);
+    c++;
+    GNUNET_HELLO_address_free (w->address);
+    if (NULL != w->test_task)
+      GNUNET_SCHEDULER_cancel (w->test_task);
+    GNUNET_free (w->addrstring);
+    GNUNET_free (w);
+  }
   if (c > 0)
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove %u addresses\n",
-                 c);
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove %u addresses\n",
+                c);
+  }
 
   if (NULL != stats)
-    {
-      GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }
 
   if (NULL != suid_helper)
-    {
-      GNUNET_HELPER_stop(suid_helper, GNUNET_NO);
-      suid_helper = NULL;
-    }
+  {
+    GNUNET_HELPER_stop (suid_helper, GNUNET_NO);
+    suid_helper = NULL;
+  }
 
   ok = 1;
 }
 
 static void
-wait_end(void *cls)
+wait_end (void *cls)
 {
   timeout_wait = NULL;
   if (0 == addresses_reported)
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-               "Plugin did not report any addresses, could not check address conversion functions\n");
-  end();
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Plugin did not report any addresses, could not check address conversion functions\n");
+  end ();
 }
 
 
 static void
-end_badly_now()
+end_badly_now ()
 {
   if (NULL != timeout_wait)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_wait);
-      timeout_wait = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_wait);
+    timeout_wait = NULL;
+  }
   if (NULL != timeout_endbadly)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_endbadly);
-      timeout_endbadly = NULL;
-    }
-  timeout_endbadly = GNUNET_SCHEDULER_add_now(&end_badly, NULL);
+  {
+    GNUNET_SCHEDULER_cancel (timeout_endbadly);
+    timeout_endbadly = NULL;
+  }
+  timeout_endbadly = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 }
 
 
 static struct GNUNET_TIME_Relative
-env_receive(void *cls,
-            const struct GNUNET_HELLO_Address *address,
-            struct GNUNET_ATS_Session *session,
-            const struct GNUNET_MessageHeader *message)
+env_receive (void *cls,
+             const struct GNUNET_HELLO_Address *address,
+             struct GNUNET_ATS_Session *session,
+             const struct GNUNET_MessageHeader *message)
 {
   /* do nothing */
-  return GNUNET_TIME_relative_get_zero_();
+  return GNUNET_TIME_relative_get_zero_ ();
 }
 
 static int got_reply;
@@ -303,28 +305,28 @@ static int got_reply;
  * @param res result code
  */
 static void
-address_pretty_printer_cb(void *cls, const char *address, int res)
+address_pretty_printer_cb (void *cls, const char *address, int res)
 {
   if (NULL != address)
-    {
-      got_reply = GNUNET_YES;
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Pretty address : `%s'\n", address);
-      pretty_printers_running--;
-    }
+  {
+    got_reply = GNUNET_YES;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Pretty address : `%s'\n", address);
+    pretty_printers_running--;
+  }
   else
+  {
+    if (GNUNET_NO == got_reply)
     {
-      if (GNUNET_NO == got_reply)
-        {
-          pretty_printers_running--;
-          GNUNET_break(0);
-          end_badly_now();
-        }
+      pretty_printers_running--;
+      GNUNET_break (0);
+      end_badly_now ();
     }
+  }
 }
 
 
 static void
-test_addr_string(void *cls)
+test_addr_string (void *cls)
 {
   struct AddressWrapper *w = cls;
   void *s2a;
@@ -332,40 +334,41 @@ test_addr_string(void *cls)
 
   w->test_task = NULL;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Testing: address_to_string \n");
-  w->addrstring = GNUNET_strdup(api->address_to_string(api,
-                                                       w->address->address,
-                                                       w->address->address_length));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Testing: address_to_string \n");
+  w->addrstring = GNUNET_strdup (api->address_to_string (api,
+                                                         w->address->address,
+                                                         w->address->
+                                                         address_length));
   if (NULL == w->addrstring)
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Plugin cannot convert address to string!\n");
-      end_badly_now();
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Plugin added address `%s'\n",
-             w->addrstring);
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Testing address_to_string: OK\n");
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Testing: string_to_address \n");
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin cannot convert address to string!\n");
+    end_badly_now ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Plugin added address `%s'\n",
+              w->addrstring);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Testing address_to_string: OK\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Testing: string_to_address \n");
   s2a = NULL;
   s2a_len = 0;
   if ((GNUNET_OK !=
-       api->string_to_address(api, w->addrstring,
-                              strlen(w->addrstring) + 1,
-                              &s2a, &s2a_len)) ||
+       api->string_to_address (api, w->addrstring,
+                               strlen (w->addrstring) + 1,
+                               &s2a, &s2a_len)) ||
       (NULL == s2a))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Plugin cannot convert string to address!\n");
-      end_badly_now();
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin cannot convert string to address!\n");
+    end_badly_now ();
+    return;
+  }
 
   /*
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
@@ -376,164 +379,166 @@ test_addr_string(void *cls)
      fprintf (stderr, "%u == %u\n", ((char *) s2a)[c1], ((char *) w->addr)[c1]);
    */
   if (s2a_len != w->address->address_length)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Plugin creates different address length when converting address->string->address: %u != %u\n",
-                 (unsigned int)w->address->address_length,
-                 (unsigned int)s2a_len);
-    }
-  else if (0 != memcmp(s2a, w->address->address, s2a_len))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Plugin creates different address length when converting back and forth %i!\n",
-                 memcmp(s2a,
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin creates different address length when converting address->string->address: %u != %u\n",
+                (unsigned int) w->address->address_length,
+                (unsigned int) s2a_len);
+  }
+  else if (0 != memcmp (s2a, w->address->address, s2a_len))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin creates different address length when converting back and forth %i!\n",
+                memcmp (s2a,
                         w->address->address,
                         s2a_len));
-    }
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Testing string_to_address: OK\n");
-    }
-  GNUNET_free(s2a);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Testing string_to_address: OK\n");
+  }
+  GNUNET_free (s2a);
 
   pretty_printers_running++;
-  api->address_pretty_printer(api->cls,
-                              w->address->transport_name,
-                              w->address->address,
-                              w->address->address_length,
-                              GNUNET_YES,
-                              GNUNET_TIME_UNIT_MINUTES,
-                              &address_pretty_printer_cb, w);
+  api->address_pretty_printer (api->cls,
+                               w->address->transport_name,
+                               w->address->address,
+                               w->address->address_length,
+                               GNUNET_YES,
+                               GNUNET_TIME_UNIT_MINUTES,
+                               &address_pretty_printer_cb, w);
 
   if (GNUNET_OK !=
-      api->check_address(api->cls,
-                         w->address->address,
-                         w->address->address_length))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Plugin refuses added address!\n");
-      end_badly_now();
-      return;
-    }
+      api->check_address (api->cls,
+                          w->address->address,
+                          w->address->address_length))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin refuses added address!\n");
+    end_badly_now ();
+    return;
+  }
   if (NULL != timeout_wait)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_wait);
-      timeout_wait = NULL;
-    }
-  timeout_wait = GNUNET_SCHEDULER_add_delayed(WAIT, &wait_end, NULL);
+  {
+    GNUNET_SCHEDULER_cancel (timeout_wait);
+    timeout_wait = NULL;
+  }
+  timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
 }
 
 
 static void
-env_notify_address(void *cls,
-                   int add_remove,
-                   const struct GNUNET_HELLO_Address *address)
+env_notify_address (void *cls,
+                    int add_remove,
+                    const struct GNUNET_HELLO_Address *address)
 {
   struct AddressWrapper *w;
   struct AddressWrapper *wtmp;
 
   if (GNUNET_YES == add_remove)
-    {
-      addresses_reported++;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Adding address of length %u\n",
-                 (unsigned int)address->address_length);
-
-      for (wtmp = head; NULL != wtmp; wtmp = wtmp->next)
-        {
-          if ((address->address_length == wtmp->address->address_length) &&
-              (0 == memcmp(address->address, wtmp->address->address, address->address_length)))
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         "Duplicate address notification .... \n");
-              return;
-            }
-        }
-
-      w = GNUNET_new(struct AddressWrapper);
-      w->address = GNUNET_HELLO_address_copy(address);
-      GNUNET_CONTAINER_DLL_insert(head, tail, w);
-      got_reply = GNUNET_NO;
-      w->test_task = GNUNET_SCHEDULER_add_now(&test_addr_string,
-                                              w);
-      return;
-    }
+  {
+    addresses_reported++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Adding address of length %u\n",
+                (unsigned int) address->address_length);
+
+    for (wtmp = head; NULL != wtmp; wtmp = wtmp->next)
+    {
+      if ((address->address_length == wtmp->address->address_length) &&
+          (0 == memcmp (address->address, wtmp->address->address,
+                        address->address_length)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Duplicate address notification .... \n");
+        return;
+      }
+    }
+
+    w = GNUNET_new (struct AddressWrapper);
+    w->address = GNUNET_HELLO_address_copy (address);
+    GNUNET_CONTAINER_DLL_insert (head, tail, w);
+    got_reply = GNUNET_NO;
+    w->test_task = GNUNET_SCHEDULER_add_now (&test_addr_string,
+                                             w);
+    return;
+  }
 
   if (GNUNET_NO == add_remove)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Removing address of length %u\n",
-                 (unsigned int)address->address_length);
-      w = head;
-      while (NULL != w)
-        {
-          if ((address->address_length == w->address->address_length) &&
-              (0 == memcmp(w->address->address, address->address, address->address_length)))
-            {
-              break;
-            }
-          w = w->next;
-        }
-
-      if (w == NULL)
-        {
-          GNUNET_break(0);
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Plugin removes address never added!\n");
-          end_badly_now();
-          return;
-        }
-
-      GNUNET_CONTAINER_DLL_remove(head, tail, w);
-      GNUNET_HELLO_address_free(w->address);
-      GNUNET_free(w->addrstring);
-      GNUNET_free(w);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Removing address of length %u\n",
+                (unsigned int) address->address_length);
+    w = head;
+    while (NULL != w)
+    {
+      if ((address->address_length == w->address->address_length) &&
+          (0 == memcmp (w->address->address, address->address,
+                        address->address_length)))
+      {
+        break;
+      }
+      w = w->next;
+    }
+
+    if (w == NULL)
+    {
+      GNUNET_break (0);
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Plugin removes address never added!\n");
+      end_badly_now ();
       return;
     }
-  GNUNET_break(0);
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Invalid operation: %u\n",
-             add_remove);
-  end_badly_now();
+
+    GNUNET_CONTAINER_DLL_remove (head, tail, w);
+    GNUNET_HELLO_address_free (w->address);
+    GNUNET_free (w->addrstring);
+    GNUNET_free (w);
+    return;
+  }
+  GNUNET_break (0);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Invalid operation: %u\n",
+              add_remove);
+  end_badly_now ();
 }
 
 
 static enum GNUNET_NetworkType
-env_get_address_type(void *cls,
-                     const struct sockaddr *addr,
-                     size_t addrlen)
+env_get_address_type (void *cls,
+                      const struct sockaddr *addr,
+                      size_t addrlen)
 {
   return GNUNET_NT_LOOPBACK;
 }
 
 
 static const struct GNUNET_MessageHeader *
-env_get_our_hello()
+env_get_our_hello ()
 {
-  return (const struct GNUNET_MessageHeader *)hello;
+  return (const struct GNUNET_MessageHeader *) hello;
 }
 
 
 static void
-env_session_end(void *cls,
-                const struct GNUNET_HELLO_Address *address,
-                struct GNUNET_ATS_Session *session)
+env_session_end (void *cls,
+                 const struct GNUNET_HELLO_Address *address,
+                 struct GNUNET_ATS_Session *session)
 {
 }
 
 
 static void
-env_update_distance(void *cls,
-                    const struct GNUNET_HELLO_Address *address,
-                    uint32_t distance)
+env_update_distance (void *cls,
+                     const struct GNUNET_HELLO_Address *address,
+                     uint32_t distance)
 {
 }
 
 
 static void
-setup_plugin_environment()
+setup_plugin_environment ()
 {
   env.cfg = cfg;
   env.cls = &env;
@@ -550,8 +555,8 @@ setup_plugin_environment()
 
 
 static int
-handle_helper_message(void *cls,
-                      const struct GNUNET_MessageHeader *hdr)
+handle_helper_message (void *cls,
+                       const struct GNUNET_MessageHeader *hdr)
 {
   return GNUNET_OK;
 }
@@ -564,184 +569,185 @@ handle_helper_message(void *cls,
  * @param c configuration to use
  */
 static void
-run(void *cls,
-    char * const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  char * const *argv = cls;
+  char *const *argv = cls;
   unsigned long long tneigh;
   char *keyfile;
   char *plugin;
   char *sep;
 
-  timeout_endbadly = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
-                                                  &end_badly,
-                                                  &ok);
+  timeout_endbadly = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                                   &end_badly,
+                                                   &ok);
   cfg = c;
   /* parse configuration */
   if ((GNUNET_OK !=
-       GNUNET_CONFIGURATION_get_value_number(c,
-                                             "TRANSPORT",
-                                             "NEIGHBOUR_LIMIT",
-                                             &tneigh)) ||
+       GNUNET_CONFIGURATION_get_value_number (c,
+                                              "TRANSPORT",
+                                              "NEIGHBOUR_LIMIT",
+                                              &tneigh)) ||
       (GNUNET_OK !=
-       GNUNET_CONFIGURATION_get_value_filename(c,
-                                               "PEER",
-                                               "PRIVATE_KEY",
-                                               &keyfile)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Transport service is lacking key configuration settings.  Exiting.\n");
-      return;
-    }
-
-  if (NULL == (stats = GNUNET_STATISTICS_create("transport",
-                                                cfg)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Could not create statistics.  Exiting.\n");
-      GNUNET_free(keyfile);
-      end_badly_now();
-      return;
-    }
-
-  if (GNUNET_OK != GNUNET_DISK_file_test(HOSTKEY_FILE))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Hostkey `%s' missing.  Exiting.\n",
-                 HOSTKEY_FILE);
-      GNUNET_free(keyfile);
-      end_badly_now();
-      return;
-    }
+       GNUNET_CONFIGURATION_get_value_filename (c,
+                                                "PEER",
+                                                "PRIVATE_KEY",
+                                                &keyfile)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Transport service is lacking key configuration settings.  Exiting.\n");
+    return;
+  }
+
+  if (NULL == (stats = GNUNET_STATISTICS_create ("transport",
+                                                 cfg)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not create statistics.  Exiting.\n");
+    GNUNET_free (keyfile);
+    end_badly_now ();
+    return;
+  }
+
+  if (GNUNET_OK != GNUNET_DISK_file_test (HOSTKEY_FILE))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Hostkey `%s' missing.  Exiting.\n",
+                HOSTKEY_FILE);
+    GNUNET_free (keyfile);
+    end_badly_now ();
+    return;
+  }
 
   if (GNUNET_OK !=
-      GNUNET_DISK_directory_create_for_file(keyfile))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Could not create a directory for hostkey `%s'.  Exiting.\n",
-                 keyfile);
-      GNUNET_free(keyfile);
-      end_badly_now();
-      return;
-    }
+      GNUNET_DISK_directory_create_for_file (keyfile))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not create a directory for hostkey `%s'.  Exiting.\n",
+                keyfile);
+    GNUNET_free (keyfile);
+    end_badly_now ();
+    return;
+  }
 
   if (GNUNET_OK !=
-      GNUNET_DISK_file_copy(HOSTKEY_FILE,
-                            keyfile))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Could not copy hostkey `%s' to destination `%s'.  Exiting.\n",
-                 HOSTKEY_FILE,
-                 keyfile);
-      GNUNET_free(keyfile);
-      end_badly_now();
-      return;
-    }
-
-  max_connect_per_transport = (uint32_t)tneigh;
-  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_file(keyfile);
-  GNUNET_free(keyfile);
+      GNUNET_DISK_file_copy (HOSTKEY_FILE,
+                             keyfile))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not copy hostkey `%s' to destination `%s'.  Exiting.\n",
+                HOSTKEY_FILE,
+                keyfile);
+    GNUNET_free (keyfile);
+    end_badly_now ();
+    return;
+  }
+
+  max_connect_per_transport = (uint32_t) tneigh;
+  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
+  GNUNET_free (keyfile);
   if (NULL == my_private_key)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Could not access hostkey.  Exiting.\n");
-      end_badly_now();
-      return;
-    }
-  GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not access hostkey.  Exiting.\n");
+    end_badly_now ();
+    return;
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
 
-  hello = GNUNET_HELLO_create(&my_identity.public_key, NULL, NULL, GNUNET_NO);
+  hello = GNUNET_HELLO_create (&my_identity.public_key, NULL, NULL, GNUNET_NO);
 
   /* load plugins... */
-  setup_plugin_environment();
+  setup_plugin_environment ();
 
-  GNUNET_assert(strlen(argv[0]) > strlen("test_plugin_"));
-  plugin = strstr(argv[0], "test_plugin_");
-  sep = strrchr(argv[0], '.');
+  GNUNET_assert (strlen (argv[0]) > strlen ("test_plugin_"));
+  plugin = strstr (argv[0], "test_plugin_");
+  sep = strrchr (argv[0], '.');
   if (NULL == plugin)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Not a valid test name\n");
-      end_badly_now();
-      return;
-    }
-  plugin += strlen("test_plugin_");
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Not a valid test name\n");
+    end_badly_now ();
+    return;
+  }
+  plugin += strlen ("test_plugin_");
   if (NULL != sep)
     sep[0] = '\0';
 
   /* Hack for WLAN: start a second helper */
-  if (0 == strcmp(plugin, "wlan"))
-    {
-      char * helper_argv[3];
-      helper_argv[0] = (char *)"gnunet-helper-transport-wlan-dummy";
-      helper_argv[1] = (char *)"2";
-      helper_argv[2] = NULL;
-      suid_helper = GNUNET_HELPER_start(GNUNET_NO,
-                                        "gnunet-helper-transport-wlan-dummy", helper_argv,
-                                        &handle_helper_message, NULL, NULL);
-    }
+  if (0 == strcmp (plugin, "wlan"))
+  {
+    char *helper_argv[3];
+    helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy";
+    helper_argv[1] = (char *) "2";
+    helper_argv[2] = NULL;
+    suid_helper = GNUNET_HELPER_start (GNUNET_NO,
+                                       "gnunet-helper-transport-wlan-dummy",
+                                       helper_argv,
+                                       &handle_helper_message, NULL, NULL);
+  }
 
   /* Loading plugin */
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Loading transport plugin %s\n", plugin);
-  GNUNET_asprintf(&libname, "libgnunet_plugin_transport_%s", plugin);
-  api = GNUNET_PLUGIN_load(libname, &env);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Loading transport plugin %s\n", plugin);
+  GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", plugin);
+  api = GNUNET_PLUGIN_load (libname, &env);
   if (NULL == api)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Failed to load transport plugin for %s\n", plugin);
-      end_badly_now();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to load transport plugin for %s\n", plugin);
+    end_badly_now ();
+    return;
+  }
 
-  timeout_wait = GNUNET_SCHEDULER_add_delayed(WAIT, &wait_end, NULL);
+  timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
 
   /* Check if all functions are implemented */
   if (NULL == api->address_pretty_printer)
-    {
-      GNUNET_break(0);
-      end_badly_now();
-      return;
-    }
+  {
+    GNUNET_break (0);
+    end_badly_now ();
+    return;
+  }
   if (NULL == api->address_to_string)
-    {
-      GNUNET_break(0);
-      end_badly_now();
-      return;
-    }
-  GNUNET_assert(NULL != api->check_address);
+  {
+    GNUNET_break (0);
+    end_badly_now ();
+    return;
+  }
+  GNUNET_assert (NULL != api->check_address);
   if (NULL == api->check_address)
-    {
-      GNUNET_break(0);
-      end_badly_now();
-      return;
-    }
-  GNUNET_assert(NULL != api->disconnect_peer);
+  {
+    GNUNET_break (0);
+    end_badly_now ();
+    return;
+  }
+  GNUNET_assert (NULL != api->disconnect_peer);
   if (NULL == api->disconnect_peer)
-    {
-      GNUNET_break(0);
-      end_badly_now();
-      return;
-    }
-  GNUNET_assert(NULL != api->get_session);
+  {
+    GNUNET_break (0);
+    end_badly_now ();
+    return;
+  }
+  GNUNET_assert (NULL != api->get_session);
   if (NULL == api->get_session)
-    {
-      GNUNET_break(0);
-      end_badly_now();
-      return;
-    }
+  {
+    GNUNET_break (0);
+    end_badly_now ();
+    return;
+  }
   if (NULL == api->address_pretty_printer)
-    {
-      GNUNET_break(0);
-      end_badly_now();
-      return;
-    }
+  {
+    GNUNET_break (0);
+    end_badly_now ();
+    return;
+  }
   if (NULL == api->string_to_address)
-    {
-      GNUNET_break(0);
-      end_badly_now();
-      return;
-    }
+  {
+    GNUNET_break (0);
+    end_badly_now ();
+    return;
+  }
 }
 
 
@@ -753,32 +759,32 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc,
-     char * const *argv)
+main (int argc,
+      char *const *argv)
 {
   static struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
-  char * const argv_prog[] = {
+  char *const argv_prog[] = {
     "test_plugin_transport",
     "-c",
     "test_plugin_transport_data.conf",
     NULL
   };
 
-  GNUNET_log_setup("test-plugin-transport",
-                   "WARNING",
-                   NULL);
-  GNUNET_DISK_purge_cfg_dir("test_plugin_transport_data.conf",
-                            "GNUNET_TEST_HOME");
+  GNUNET_log_setup ("test-plugin-transport",
+                    "WARNING",
+                    NULL);
+  GNUNET_DISK_purge_cfg_dir ("test_plugin_transport_data.conf",
+                             "GNUNET_TEST_HOME");
   ok = 1; /* set to fail */
   ret =
     (GNUNET_OK
-     == GNUNET_PROGRAM_run(3, argv_prog, "test-plugin-transport",
-                           "testcase", options, &run, (void *)argv)) ? ok : 1;
-  GNUNET_DISK_purge_cfg_dir("test_plugin_transport_data.conf",
-                            "GNUNET_TEST_HOME");
+     == GNUNET_PROGRAM_run (3, argv_prog, "test-plugin-transport",
+                            "testcase", options, &run, (void *) argv)) ? ok : 1;
+  GNUNET_DISK_purge_cfg_dir ("test_plugin_transport_data.conf",
+                             "GNUNET_TEST_HOME");
   return ret;
 }