global reindent, now with uncrustify hook enabled

8 files changed, 2035 insertions, 2022 deletions

diff --git a/src/hostlist/gnunet-daemon-hostlist.c b/src/hostlist/gnunet-daemon-hostlist.c
index 7c1863dc0..bf6542d7f 100644
--- a/src/hostlist/gnunet-daemon-hostlist.c
+++ b/src/hostlist/gnunet-daemon-hostlist.c
@@ -102,7 +102,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  *    unaligned!)
  * 4) address (address-length bytes; possibly unaligned!)
  */
-struct GNUNET_HOSTLIST_ADV_Message {
+struct GNUNET_HOSTLIST_ADV_Message
+{
   /**
    * Type will be GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT.
    */
@@ -129,8 +130,8 @@ static struct GNUNET_PeerIdentity me;
  * @param my_identity our peer's identity
  */
 static void
-core_init(void *cls,
-          const struct GNUNET_PeerIdentity *my_identity)
+core_init (void *cls,
+           const struct GNUNET_PeerIdentity *my_identity)
 {
   me = *my_identity;
 }
@@ -144,26 +145,26 @@ core_init(void *cls,
  * @return #GNUNET_OK if message is well-formed
  */
 static int
-check_advertisement(void *cls,
-                    const struct GNUNET_MessageHeader *message)
+check_advertisement (void *cls,
+                     const struct GNUNET_MessageHeader *message)
 {
   size_t size;
   size_t uri_size;
   const char *uri;
 
-  size = ntohs(message->size);
+  size = ntohs (message->size);
   if (size <= sizeof(struct GNUNET_MessageHeader))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  uri = (const char *)&message[1];
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  uri = (const char *) &message[1];
   uri_size = size - sizeof(struct GNUNET_MessageHeader);
   if (uri[uri_size - 1] != '\0')
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -176,13 +177,13 @@ check_advertisement(void *cls,
  * @return #GNUNET_OK on success
  */
 static void
-handle_advertisement(void *cls,
-                     const struct GNUNET_MessageHeader *message)
+handle_advertisement (void *cls,
+                      const struct GNUNET_MessageHeader *message)
 {
-  const char *uri = (const char *)&message[1];
+  const char *uri = (const char *) &message[1];
 
-  GNUNET_assert(NULL != client_adv_handler);
-  (void)(*client_adv_handler)(uri);
+  GNUNET_assert (NULL != client_adv_handler);
+  (void) (*client_adv_handler)(uri);
 }
 
 
@@ -196,28 +197,28 @@ handle_advertisement(void *cls,
  * @return peer
  */
 static void *
-connect_handler(void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                struct GNUNET_MQ_Handle *mq)
+connect_handler (void *cls,
+                 const struct GNUNET_PeerIdentity *peer,
+                 struct GNUNET_MQ_Handle *mq)
 {
-  if (0 == GNUNET_memcmp(&me,
-                         peer))
+  if (0 == GNUNET_memcmp (&me,
+                          peer))
     return NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "A new peer connected, notifying client and server\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "A new peer connected, notifying client and server\n");
   if (NULL != client_ch)
-    GNUNET_assert(NULL ==
-                  (*client_ch)(cls,
-                               peer,
-                               mq));
+    GNUNET_assert (NULL ==
+                   (*client_ch)(cls,
+                                peer,
+                                mq));
 #if HAVE_MHD
   if (NULL != server_ch)
-    GNUNET_assert(NULL ==
-                  (*server_ch)(cls,
-                               peer,
-                               mq));
+    GNUNET_assert (NULL ==
+                   (*server_ch)(cls,
+                                peer,
+                                mq));
 #endif
-  return (void *)peer;
+  return (void *) peer;
 }
 
 
@@ -229,12 +230,12 @@ connect_handler(void *cls,
  * @param peer peer identity this notification is about
  */
 static void
-disconnect_handler(void *cls,
-                   const struct GNUNET_PeerIdentity *peer,
-                   void *internal_cls)
+disconnect_handler (void *cls,
+                    const struct GNUNET_PeerIdentity *peer,
+                    void *internal_cls)
 {
-  if (0 == GNUNET_memcmp(&me,
-                         peer))
+  if (0 == GNUNET_memcmp (&me,
+                          peer))
     return;
   /* call hostlist client disconnect handler */
   if (NULL != client_dh)
@@ -251,31 +252,31 @@ disconnect_handler(void *cls,
  * @param cls NULL
  */
 static void
-cleaning_task(void *cls)
+cleaning_task (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Hostlist daemon is shutting down\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Hostlist daemon is shutting down\n");
   if (NULL != core)
-    {
-      GNUNET_CORE_disconnect(core);
-      core = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (core);
+    core = NULL;
+  }
   if (bootstrapping)
-    {
-      GNUNET_HOSTLIST_client_stop();
-    }
+  {
+    GNUNET_HOSTLIST_client_stop ();
+  }
 #if HAVE_MHD
   if (provide_hostlist)
-    {
-      GNUNET_HOSTLIST_server_stop();
-    }
+  {
+    GNUNET_HOSTLIST_server_stop ();
+  }
 #endif
   if (NULL != stats)
-    {
-      GNUNET_STATISTICS_destroy(stats,
-                                GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats,
+                               GNUNET_NO);
+    stats = NULL;
+  }
 }
 
 
@@ -288,72 +289,73 @@ cleaning_task(void *cls)
  * @param cfg configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_MQ_MessageHandler learn_handlers[] = {
-    GNUNET_MQ_hd_var_size(advertisement,
-                          GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT,
-                          struct GNUNET_MessageHeader,
-                          NULL),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (advertisement,
+                           GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_MessageHandler no_learn_handlers[] = {
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_handler_end ()
   };
 
-  if ((!bootstrapping) && (!learning)
+  if ((! bootstrapping) && (! learning)
 #if HAVE_MHD
-      && (!provide_hostlist)
+      && (! provide_hostlist)
 #endif
       )
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("None of the functions for the hostlist daemon were enabled.  I have no reason to run!\n"));
-      return;
-    }
-  stats = GNUNET_STATISTICS_create("hostlist", cfg);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "None of the functions for the hostlist daemon were enabled.  I have no reason to run!\n"));
+    return;
+  }
+  stats = GNUNET_STATISTICS_create ("hostlist", cfg);
   if (NULL == stats)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   if (bootstrapping)
-    GNUNET_HOSTLIST_client_start(cfg,
-                                 stats,
-                                 &client_ch,
-                                 &client_dh,
-                                 &client_adv_handler,
-                                 learning);
+    GNUNET_HOSTLIST_client_start (cfg,
+                                  stats,
+                                  &client_ch,
+                                  &client_dh,
+                                  &client_adv_handler,
+                                  learning);
   core =
-    GNUNET_CORE_connect(cfg,
-                        NULL,
-                        &core_init,
-                        &connect_handler,
-                        &disconnect_handler,
-                        learning ? learn_handlers : no_learn_handlers);
+    GNUNET_CORE_connect (cfg,
+                         NULL,
+                         &core_init,
+                         &connect_handler,
+                         &disconnect_handler,
+                         learning ? learn_handlers : no_learn_handlers);
 
 
 #if HAVE_MHD
   if (provide_hostlist)
-    GNUNET_HOSTLIST_server_start(cfg,
-                                 stats,
-                                 core,
-                                 &server_ch,
-                                 advertising);
+    GNUNET_HOSTLIST_server_start (cfg,
+                                  stats,
+                                  core,
+                                  &server_ch,
+                                  advertising);
 #endif
-  GNUNET_SCHEDULER_add_shutdown(&cleaning_task,
-                                NULL);
+  GNUNET_SCHEDULER_add_shutdown (&cleaning_task,
+                                 NULL);
 
   if (NULL == core)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to connect to `%s' service.\n"), "core");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to connect to `%s' service.\n"), "core");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 }
 
 
@@ -365,46 +367,49 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
 #if HAVE_MHD
-    GNUNET_GETOPT_option_flag('a',
-                              "advertise",
-                              gettext_noop("advertise our hostlist to other peers"),
-                              &advertising),
+    GNUNET_GETOPT_option_flag ('a',
+                               "advertise",
+                               gettext_noop (
+                                 "advertise our hostlist to other peers"),
+                               &advertising),
 #endif
-    GNUNET_GETOPT_option_flag('b',
-                              "bootstrap",
-                              gettext_noop("bootstrap using hostlists (it is highly recommended that you always use this option)"),
-                              &bootstrapping),
-    GNUNET_GETOPT_option_flag('e',
-                              "enable-learning",
-                              gettext_noop("enable learning about hostlist servers from other peers"),
-                              &learning),
+    GNUNET_GETOPT_option_flag ('b',
+                               "bootstrap",
+                               gettext_noop (
+                                 "bootstrap using hostlists (it is highly recommended that you always use this option)"),
+                               &bootstrapping),
+    GNUNET_GETOPT_option_flag ('e',
+                               "enable-learning",
+                               gettext_noop (
+                                 "enable learning about hostlist servers from other peers"),
+                               &learning),
 #if HAVE_MHD
-    GNUNET_GETOPT_option_flag('p',
-                              "provide-hostlist",
-                              gettext_noop("provide a hostlist server"),
-                              &provide_hostlist),
+    GNUNET_GETOPT_option_flag ('p',
+                               "provide-hostlist",
+                               gettext_noop ("provide a hostlist server"),
+                               &provide_hostlist),
 #endif
     GNUNET_GETOPT_OPTION_END
   };
 
   int ret;
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
-  GNUNET_log_setup("hostlist", "WARNING", NULL);
+  GNUNET_log_setup ("hostlist", "WARNING", NULL);
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run(argc, argv,
-                        "hostlist",
-                        _("GNUnet hostlist server and client"),
-                        options,
-                        &run, NULL)) ? 0 : 1;
-  GNUNET_free((void*)argv);
+     GNUNET_PROGRAM_run (argc, argv,
+                         "hostlist",
+                         _ ("GNUnet hostlist server and client"),
+                         options,
+                         &run, NULL)) ? 0 : 1;
+  GNUNET_free ((void*) argv);
   return ret;
 }
 
diff --git a/src/hostlist/gnunet-daemon-hostlist_client.c b/src/hostlist/gnunet-daemon-hostlist_client.c
index af3fd6fce..564aef2bd 100644
--- a/src/hostlist/gnunet-daemon-hostlist_client.c
+++ b/src/hostlist/gnunet-daemon-hostlist_client.c
@@ -49,19 +49,19 @@
  * Time interval hostlists are saved to disk
  */
 #define SAVING_INTERVAL \
-  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
 
 /**
  * Time interval between two hostlist tests
  */
 #define TESTING_INTERVAL \
-  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 3)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3)
 
 /**
  * Time interval for download dispatcher before a download is re-scheduled
  */
 #define WAITING_INTERVAL \
-  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 
 /**
  * Defines concerning the hostlist quality metric
@@ -91,7 +91,8 @@
 /**
  * A single hostlist obtained by hostlist advertisements
  */
-struct Hostlist {
+struct Hostlist
+{
   /**
    * previous entry, used to manage entries in a double linked list
    */
@@ -320,7 +321,7 @@ static struct GNUNET_PEERINFO_Handle *pi;
  * @return number of bytes that were processed (always size*nmemb)
  */
 static size_t
-callback_download(void *ptr, size_t size, size_t nmemb, void *ctx)
+callback_download (void *ptr, size_t size, size_t nmemb, void *ctx)
 {
   static char download_buffer[GNUNET_MAX_MESSAGE_SIZE - 1];
   const char *cbuf = ptr;
@@ -333,85 +334,85 @@ callback_download(void *ptr, size_t size, size_t nmemb, void *ctx)
   total = size * nmemb;
   stat_bytes_downloaded += total;
   if ((total == 0) || (stat_bogus_url))
-    {
-      return total; /* ok, no data or bogus data */
-    }
-
-  GNUNET_STATISTICS_update(stats,
-                           gettext_noop(
-                             "# bytes downloaded from hostlist servers"),
-                           (int64_t)total,
-                           GNUNET_NO);
+  {
+    return total;   /* ok, no data or bogus data */
+  }
+
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop (
+                              "# bytes downloaded from hostlist servers"),
+                            (int64_t) total,
+                            GNUNET_NO);
   left = total;
   while ((left > 0) || (download_pos > 0))
+  {
+    cpy = GNUNET_MIN (left, GNUNET_MAX_MESSAGE_SIZE - 1 - download_pos);
+    GNUNET_memcpy (&download_buffer[download_pos], cbuf, cpy);
+    cbuf += cpy;
+    download_pos += cpy;
+    left -= cpy;
+    if (download_pos < sizeof(struct GNUNET_MessageHeader))
     {
-      cpy = GNUNET_MIN(left, GNUNET_MAX_MESSAGE_SIZE - 1 - download_pos);
-      GNUNET_memcpy(&download_buffer[download_pos], cbuf, cpy);
-      cbuf += cpy;
-      download_pos += cpy;
-      left -= cpy;
-      if (download_pos < sizeof(struct GNUNET_MessageHeader))
-        {
-          GNUNET_assert(0 == left);
-          break;
-        }
-      msg = (const struct GNUNET_MessageHeader *)download_buffer;
-      msize = ntohs(msg->size);
-      if (msize < sizeof(struct GNUNET_MessageHeader))
-        {
-          GNUNET_STATISTICS_update(
-            stats,
-            gettext_noop("# invalid HELLOs downloaded from hostlist servers"),
-            1,
-            GNUNET_NO);
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     _("Invalid `%s' message received from hostlist at `%s'\n"),
-                     "HELLO",
-                     current_url);
-          stat_hellos_obtained++;
-          stat_bogus_url = 1;
-          return total;
-        }
-      if (download_pos < msize)
-        {
-          GNUNET_assert(left == 0);
-          break;
-        }
-      if (GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)msg) == msize)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Received valid `%s' message from hostlist server.\n",
-                     "HELLO");
-          GNUNET_STATISTICS_update(
-            stats,
-            gettext_noop("# valid HELLOs downloaded from hostlist servers"),
-            1,
-            GNUNET_NO);
-          stat_hellos_obtained++;
-          (void)
-          GNUNET_PEERINFO_add_peer(pi,
-                                   (const struct GNUNET_HELLO_Message *)msg,
-                                   NULL,
-                                   NULL);
-        }
-      else
-        {
-          GNUNET_STATISTICS_update(
-            stats,
-            gettext_noop("# invalid HELLOs downloaded from hostlist servers"),
-            1,
-            GNUNET_NO);
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     _("Invalid `%s' message received from hostlist at `%s'\n"),
-                     "HELLO",
-                     current_url);
-          stat_bogus_url = GNUNET_YES;
-          stat_hellos_obtained++;
-          return total;
-        }
-      memmove(download_buffer, &download_buffer[msize], download_pos - msize);
-      download_pos -= msize;
+      GNUNET_assert (0 == left);
+      break;
+    }
+    msg = (const struct GNUNET_MessageHeader *) download_buffer;
+    msize = ntohs (msg->size);
+    if (msize < sizeof(struct GNUNET_MessageHeader))
+    {
+      GNUNET_STATISTICS_update (
+        stats,
+        gettext_noop ("# invalid HELLOs downloaded from hostlist servers"),
+        1,
+        GNUNET_NO);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Invalid `%s' message received from hostlist at `%s'\n"),
+                  "HELLO",
+                  current_url);
+      stat_hellos_obtained++;
+      stat_bogus_url = 1;
+      return total;
+    }
+    if (download_pos < msize)
+    {
+      GNUNET_assert (left == 0);
+      break;
+    }
+    if (GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *) msg) == msize)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Received valid `%s' message from hostlist server.\n",
+                  "HELLO");
+      GNUNET_STATISTICS_update (
+        stats,
+        gettext_noop ("# valid HELLOs downloaded from hostlist servers"),
+        1,
+        GNUNET_NO);
+      stat_hellos_obtained++;
+      (void)
+      GNUNET_PEERINFO_add_peer (pi,
+                                (const struct GNUNET_HELLO_Message *) msg,
+                                NULL,
+                                NULL);
     }
+    else
+    {
+      GNUNET_STATISTICS_update (
+        stats,
+        gettext_noop ("# invalid HELLOs downloaded from hostlist servers"),
+        1,
+        GNUNET_NO);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Invalid `%s' message received from hostlist at `%s'\n"),
+                  "HELLO",
+                  current_url);
+      stat_bogus_url = GNUNET_YES;
+      stat_hellos_obtained++;
+      return total;
+    }
+    memmove (download_buffer, &download_buffer[msize], download_pos - msize);
+    download_pos -= msize;
+  }
   return total;
 }
 
@@ -422,63 +423,63 @@ callback_download(void *ptr, size_t size, size_t nmemb, void *ctx)
  * @return NULL if there is no URL available
  */
 static char *
-get_bootstrap_server()
+get_bootstrap_server ()
 {
   char *servers;
   char *ret;
   size_t urls;
   size_t pos;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                         "HOSTLIST",
-                                                         "SERVERS",
-                                                         &servers))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING,
-                                "hostlist",
-                                "SERVERS");
-      return NULL;
-    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                          "HOSTLIST",
+                                                          "SERVERS",
+                                                          &servers))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+                               "hostlist",
+                               "SERVERS");
+    return NULL;
+  }
 
   urls = 0;
-  if (strlen(servers) > 0)
+  if (strlen (servers) > 0)
+  {
+    urls++;
+    pos = strlen (servers) - 1;
+    while (pos > 0)
     {
-      urls++;
-      pos = strlen(servers) - 1;
-      while (pos > 0)
-        {
-          if (servers[pos] == ' ')
-            urls++;
-          pos--;
-        }
+      if (servers[pos] == ' ')
+        urls++;
+      pos--;
     }
+  }
   if (urls == 0)
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING,
-                                "hostlist",
-                                "SERVERS");
-      GNUNET_free(servers);
-      return NULL;
-    }
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+                               "hostlist",
+                               "SERVERS");
+    GNUNET_free (servers);
+    return NULL;
+  }
 
-  urls = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, urls) + 1;
-  pos = strlen(servers) - 1;
+  urls = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, urls) + 1;
+  pos = strlen (servers) - 1;
   while (pos > 0)
+  {
+    if (servers[pos] == ' ')
     {
-      if (servers[pos] == ' ')
-        {
-          urls--;
-          servers[pos] = '\0';
-        }
-      if (urls == 0)
-        {
-          pos++;
-          break;
-        }
-      pos--;
+      urls--;
+      servers[pos] = '\0';
+    }
+    if (urls == 0)
+    {
+      pos++;
+      break;
     }
-  ret = GNUNET_strdup(&servers[pos]);
-  GNUNET_free(servers);
+    pos--;
+  }
+  ret = GNUNET_strdup (&servers[pos]);
+  GNUNET_free (servers);
   return ret;
 }
 
@@ -488,64 +489,64 @@ get_bootstrap_server()
  * @return uri to use, NULL if there is no URL available
  */
 static char *
-download_get_url()
+download_get_url ()
 {
   uint32_t index;
   unsigned int counter;
   struct Hostlist *pos;
 
   if (GNUNET_NO == stat_learning)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Using preconfigured bootstrap server\n");
-      current_hostlist = NULL;
-      return get_bootstrap_server();
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Using preconfigured bootstrap server\n");
+    current_hostlist = NULL;
+    return get_bootstrap_server ();
+  }
 
   if ((GNUNET_YES == stat_testing_hostlist) && (NULL != hostlist_to_test))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Testing new advertised hostlist if it is obtainable\n");
-      current_hostlist = hostlist_to_test;
-      return GNUNET_strdup(hostlist_to_test->hostlist_uri);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Testing new advertised hostlist if it is obtainable\n");
+    current_hostlist = hostlist_to_test;
+    return GNUNET_strdup (hostlist_to_test->hostlist_uri);
+  }
 
   if ((GNUNET_YES == stat_use_bootstrap) || (linked_list_size == 0))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Using preconfigured bootstrap server\n");
-      current_hostlist = NULL;
-      return get_bootstrap_server();
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Using preconfigured bootstrap server\n");
+    current_hostlist = NULL;
+    return get_bootstrap_server ();
+  }
   index =
-    GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, linked_list_size);
+    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, linked_list_size);
   counter = 0;
   pos = linked_list_head;
   while (counter < index)
-    {
-      pos = pos->next;
-      counter++;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Using learned hostlist `%s'\n",
-             pos->hostlist_uri);
+  {
+    pos = pos->next;
+    counter++;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Using learned hostlist `%s'\n",
+              pos->hostlist_uri);
   current_hostlist = pos;
-  return GNUNET_strdup(pos->hostlist_uri);
+  return GNUNET_strdup (pos->hostlist_uri);
 }
 
 
 #define CURL_EASY_SETOPT(c, a, b)                   \
   do                                                \
-    {                                                 \
-      ret = curl_easy_setopt(c, a, b);               \
-      if (CURLE_OK != ret)                            \
+  {                                                 \
+    ret = curl_easy_setopt (c, a, b);               \
+    if (CURLE_OK != ret)                            \
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,        \
-                  _("%s failed at %s:%d: `%s'\n"), \
+                  _ ("%s failed at %s:%d: `%s'\n"), \
                   "curl_easy_setopt",               \
                   __FILE__,                         \
                   __LINE__,                         \
-                  curl_easy_strerror(ret));        \
-    } while (0)
+                  curl_easy_strerror (ret));        \
+  } while (0)
 
 
 /**
@@ -554,7 +555,7 @@ download_get_url()
  * @param shutdown set if called because of shutdown, entries in linked list will be destroyed
  */
 static void
-save_hostlist_file(int shutdown);
+save_hostlist_file (int shutdown);
 
 
 /**
@@ -565,7 +566,7 @@ save_hostlist_file(int shutdown);
  * @return result
  */
 static uint64_t
-checked_add(uint64_t val1, uint64_t val2)
+checked_add (uint64_t val1, uint64_t val2)
 {
   static uint64_t temp;
   static uint64_t maxv;
@@ -588,7 +589,7 @@ checked_add(uint64_t val1, uint64_t val2)
  * @return result
  */
 static uint64_t
-checked_sub(uint64_t val1, uint64_t val2)
+checked_sub (uint64_t val1, uint64_t val2)
 {
   if (val1 <= val2)
     return 0;
@@ -603,17 +604,17 @@ checked_sub(uint64_t val1, uint64_t val2)
  * @return #GNUNET_YES if existing in linked list, #GNUNET_NO if not
  */
 static int
-linked_list_contains(const char *uri)
+linked_list_contains (const char *uri)
 {
   struct Hostlist *pos;
 
   pos = linked_list_head;
   while (pos != NULL)
-    {
-      if (0 == strcmp(pos->hostlist_uri, uri))
-        return GNUNET_YES;
-      pos = pos->next;
-    }
+  {
+    if (0 == strcmp (pos->hostlist_uri, uri))
+      return GNUNET_YES;
+    pos = pos->next;
+  }
   return GNUNET_NO;
 }
 
@@ -623,7 +624,7 @@ linked_list_contains(const char *uri)
  * @return hostlist with lowest quality
  */
 static struct Hostlist *
-linked_list_get_lowest_quality()
+linked_list_get_lowest_quality ()
 {
   struct Hostlist *pos;
   struct Hostlist *lowest;
@@ -633,11 +634,11 @@ linked_list_get_lowest_quality()
   lowest = linked_list_head;
   pos = linked_list_head->next;
   while (pos != NULL)
-    {
-      if (pos->quality < lowest->quality)
-        lowest = pos;
-      pos = pos->next;
-    }
+  {
+    if (pos->quality < lowest->quality)
+      lowest = pos;
+    pos = pos->next;
+  }
   return lowest;
 }
 
@@ -648,34 +649,34 @@ linked_list_get_lowest_quality()
  * quality is dismissed
  */
 static void
-insert_hostlist()
+insert_hostlist ()
 {
   struct Hostlist *lowest_quality;
 
   if (MAX_NUMBER_HOSTLISTS <= linked_list_size)
-    {
-      /* No free entries available, replace existing entry  */
-      lowest_quality = linked_list_get_lowest_quality();
-      GNUNET_assert(lowest_quality != NULL);
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_DEBUG,
-        "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n",
-        lowest_quality->hostlist_uri,
-        (unsigned long long)lowest_quality->quality);
-      GNUNET_CONTAINER_DLL_remove(linked_list_head,
-                                  linked_list_tail,
-                                  lowest_quality);
-      linked_list_size--;
-      GNUNET_free(lowest_quality);
-    }
-  GNUNET_CONTAINER_DLL_insert(linked_list_head,
-                              linked_list_tail,
-                              hostlist_to_test);
+  {
+    /* No free entries available, replace existing entry  */
+    lowest_quality = linked_list_get_lowest_quality ();
+    GNUNET_assert (lowest_quality != NULL);
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n",
+      lowest_quality->hostlist_uri,
+      (unsigned long long) lowest_quality->quality);
+    GNUNET_CONTAINER_DLL_remove (linked_list_head,
+                                 linked_list_tail,
+                                 lowest_quality);
+    linked_list_size--;
+    GNUNET_free (lowest_quality);
+  }
+  GNUNET_CONTAINER_DLL_insert (linked_list_head,
+                               linked_list_tail,
+                               hostlist_to_test);
   linked_list_size++;
-  GNUNET_STATISTICS_set(stats,
-                        gettext_noop("# advertised hostlist URIs"),
-                        linked_list_size,
-                        GNUNET_NO);
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop ("# advertised hostlist URIs"),
+                         linked_list_size,
+                         GNUNET_NO);
   stat_testing_hostlist = GNUNET_NO;
 }
 
@@ -684,37 +685,37 @@ insert_hostlist()
  * Method updating hostlist statistics
  */
 static void
-update_hostlist()
+update_hostlist ()
 {
   char *stat;
 
   if (((stat_use_bootstrap == GNUNET_NO) && (NULL != current_hostlist)) ||
       ((stat_testing_hostlist == GNUNET_YES) && (NULL != current_hostlist)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Updating hostlist statics for URI `%s'\n",
+                current_hostlist->hostlist_uri);
+    current_hostlist->hello_count = stat_hellos_obtained;
+    current_hostlist->time_last_usage = GNUNET_TIME_absolute_get ();
+    current_hostlist->quality =
+      checked_add (current_hostlist->quality,
+                   (stat_hellos_obtained * HOSTLIST_SUCCESSFUL_HELLO));
+    if (GNUNET_YES == stat_download_successful)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Updating hostlist statics for URI `%s'\n",
-                 current_hostlist->hostlist_uri);
-      current_hostlist->hello_count = stat_hellos_obtained;
-      current_hostlist->time_last_usage = GNUNET_TIME_absolute_get();
+      current_hostlist->times_used++;
       current_hostlist->quality =
-        checked_add(current_hostlist->quality,
-                    (stat_hellos_obtained * HOSTLIST_SUCCESSFUL_HELLO));
-      if (GNUNET_YES == stat_download_successful)
-        {
-          current_hostlist->times_used++;
-          current_hostlist->quality =
-            checked_add(current_hostlist->quality, HOSTLIST_SUCCESSFUL_DOWNLOAD);
-          GNUNET_asprintf(&stat,
-                          gettext_noop("# advertised URI `%s' downloaded"),
-                          current_hostlist->hostlist_uri);
-
-          GNUNET_STATISTICS_update(stats, stat, 1, GNUNET_YES);
-          GNUNET_free(stat);
-        }
-      else
-        current_hostlist->quality =
-          checked_sub(current_hostlist->quality, HOSTLIST_FAILED_DOWNLOAD);
+        checked_add (current_hostlist->quality, HOSTLIST_SUCCESSFUL_DOWNLOAD);
+      GNUNET_asprintf (&stat,
+                       gettext_noop ("# advertised URI `%s' downloaded"),
+                       current_hostlist->hostlist_uri);
+
+      GNUNET_STATISTICS_update (stats, stat, 1, GNUNET_YES);
+      GNUNET_free (stat);
     }
+    else
+      current_hostlist->quality =
+        checked_sub (current_hostlist->quality, HOSTLIST_FAILED_DOWNLOAD);
+  }
   current_hostlist = NULL;
   /* Alternating the usage of preconfigured and learned hostlists */
 
@@ -722,12 +723,12 @@ update_hostlist()
     return;
 
   if (GNUNET_YES == stat_learning)
-    {
-      if (stat_use_bootstrap == GNUNET_YES)
-        stat_use_bootstrap = GNUNET_NO;
-      else
-        stat_use_bootstrap = GNUNET_YES;
-    }
+  {
+    if (stat_use_bootstrap == GNUNET_YES)
+      stat_use_bootstrap = GNUNET_NO;
+    else
+      stat_use_bootstrap = GNUNET_YES;
+  }
   else
     stat_use_bootstrap = GNUNET_YES;
 }
@@ -738,58 +739,58 @@ update_hostlist()
  * hostlist and schedule the next task.
  */
 static void
-clean_up()
+clean_up ()
 {
   CURLMcode mret;
 
   if ((stat_testing_hostlist == GNUNET_YES) &&
       (GNUNET_NO == stat_download_successful) && (NULL != hostlist_to_test))
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_INFO,
-        _(
-          "Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"),
-        hostlist_to_test->hostlist_uri);
-    }
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_INFO,
+      _ (
+        "Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"),
+      hostlist_to_test->hostlist_uri);
+  }
 
   if (stat_testing_hostlist == GNUNET_YES)
-    {
-      stat_testing_hostlist = GNUNET_NO;
-    }
+  {
+    stat_testing_hostlist = GNUNET_NO;
+  }
   if (NULL != hostlist_to_test)
-    {
-      GNUNET_free(hostlist_to_test);
-      hostlist_to_test = NULL;
-    }
+  {
+    GNUNET_free (hostlist_to_test);
+    hostlist_to_test = NULL;
+  }
 
   if (NULL != multi)
+  {
+    mret = curl_multi_remove_handle (multi, curl);
+    if (mret != CURLM_OK)
     {
-      mret = curl_multi_remove_handle(multi, curl);
-      if (mret != CURLM_OK)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     _("%s failed at %s:%d: `%s'\n"),
-                     "curl_multi_remove_handle",
-                     __FILE__,
-                     __LINE__,
-                     curl_multi_strerror(mret));
-        }
-      mret = curl_multi_cleanup(multi);
-      if (mret != CURLM_OK)
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                   _("%s failed at %s:%d: `%s'\n"),
-                   "curl_multi_cleanup",
-                   __FILE__,
-                   __LINE__,
-                   curl_multi_strerror(mret));
-      multi = NULL;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("%s failed at %s:%d: `%s'\n"),
+                  "curl_multi_remove_handle",
+                  __FILE__,
+                  __LINE__,
+                  curl_multi_strerror (mret));
     }
+    mret = curl_multi_cleanup (multi);
+    if (mret != CURLM_OK)
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("%s failed at %s:%d: `%s'\n"),
+                  "curl_multi_cleanup",
+                  __FILE__,
+                  __LINE__,
+                  curl_multi_strerror (mret));
+    multi = NULL;
+  }
   if (NULL != curl)
-    {
-      curl_easy_cleanup(curl);
-      curl = NULL;
-    }
-  GNUNET_free_non_null(current_url);
+  {
+    curl_easy_cleanup (curl);
+    curl = NULL;
+  }
+  GNUNET_free_non_null (current_url);
   current_url = NULL;
   stat_bytes_downloaded = 0;
   stat_download_in_progress = GNUNET_NO;
@@ -804,7 +805,7 @@ clean_up()
  * @param tc task context, unused
  */
 static void
-task_download(void *cls);
+task_download (void *cls);
 
 
 /**
@@ -812,7 +813,7 @@ task_download(void *cls);
  * receiving task with the scheduler.
  */
 static void
-download_prepare()
+download_prepare ()
 {
   CURLMcode mret;
   fd_set rs;
@@ -825,50 +826,50 @@ download_prepare()
   struct GNUNET_TIME_Relative rtime;
 
   max = -1;
-  FD_ZERO(&rs);
-  FD_ZERO(&ws);
-  FD_ZERO(&es);
-  mret = curl_multi_fdset(multi, &rs, &ws, &es, &max);
+  FD_ZERO (&rs);
+  FD_ZERO (&ws);
+  FD_ZERO (&es);
+  mret = curl_multi_fdset (multi, &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));
-      clean_up();
-      return;
-    }
-  mret = curl_multi_timeout(multi, &timeout);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_fdset",
+                __FILE__,
+                __LINE__,
+                curl_multi_strerror (mret));
+    clean_up ();
+    return;
+  }
+  mret = curl_multi_timeout (multi, &timeout);
   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));
-      clean_up();
-      return;
-    }
-  rtime = GNUNET_TIME_relative_min(
-    GNUNET_TIME_absolute_get_remaining(end_time),
-    GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, timeout));
-  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);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Scheduling task for hostlist download using cURL\n");
-  ti_download = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                            rtime,
-                                            grs,
-                                            gws,
-                                            &task_download,
-                                            multi);
-  GNUNET_NETWORK_fdset_destroy(gws);
-  GNUNET_NETWORK_fdset_destroy(grs);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_timeout",
+                __FILE__,
+                __LINE__,
+                curl_multi_strerror (mret));
+    clean_up ();
+    return;
+  }
+  rtime = GNUNET_TIME_relative_min (
+    GNUNET_TIME_absolute_get_remaining (end_time),
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, timeout));
+  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);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Scheduling task for hostlist download using cURL\n");
+  ti_download = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                             rtime,
+                                             grs,
+                                             gws,
+                                             &task_download,
+                                             multi);
+  GNUNET_NETWORK_fdset_destroy (gws);
+  GNUNET_NETWORK_fdset_destroy (grs);
 }
 
 
@@ -879,95 +880,95 @@ download_prepare()
  * @param cls closure, unused
  */
 static void
-task_download(void *cls)
+task_download (void *cls)
 {
   int running;
   struct CURLMsg *msg;
   CURLMcode mret;
 
   ti_download = NULL;
-  if (0 == GNUNET_TIME_absolute_get_remaining(end_time).rel_value_us)
+  if (0 == GNUNET_TIME_absolute_get_remaining (end_time).rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Timeout trying to download hostlist from `%s'\n"),
+                current_url);
+    update_hostlist ();
+    clean_up ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Ready for processing hostlist client request\n");
+  do
+  {
+    running = 0;
+    if (stat_bytes_downloaded > MAX_BYTES_PER_HOSTLISTS)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Timeout trying to download hostlist from `%s'\n"),
-                 current_url);
-      update_hostlist();
-      clean_up();
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ (
+                    "Download limit of %u bytes exceeded, stopping download\n"),
+                  MAX_BYTES_PER_HOSTLISTS);
+      clean_up ();
       return;
     }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Ready for processing hostlist client request\n");
-  do
+    mret = curl_multi_perform (multi, &running);
+    if (running == 0)
     {
-      running = 0;
-      if (stat_bytes_downloaded > MAX_BYTES_PER_HOSTLISTS)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     _(
-                       "Download limit of %u bytes exceeded, stopping download\n"),
-                     MAX_BYTES_PER_HOSTLISTS);
-          clean_up();
-          return;
-        }
-      mret = curl_multi_perform(multi, &running);
-      if (running == 0)
+      do
+      {
+        msg = curl_multi_info_read (multi, &running);
+        GNUNET_break (msg != NULL);
+        if (msg == NULL)
+          break;
+        switch (msg->msg)
         {
-          do
+        case CURLMSG_DONE:
+          if ((msg->data.result != CURLE_OK) &&
+              (msg->data.result != CURLE_GOT_NOTHING))
+            GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                        _ ("Download of hostlist from `%s' failed: `%s'\n"),
+                        current_url,
+                        curl_easy_strerror (msg->data.result));
+          else
+          {
+            GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                        _ ("Download of hostlist `%s' completed.\n"),
+                        current_url);
+            stat_download_successful = GNUNET_YES;
+            update_hostlist ();
+            if (GNUNET_YES == stat_testing_hostlist)
             {
-              msg = curl_multi_info_read(multi, &running);
-              GNUNET_break(msg != NULL);
-              if (msg == NULL)
-                break;
-              switch (msg->msg)
-                {
-                case CURLMSG_DONE:
-                  if ((msg->data.result != CURLE_OK) &&
-                      (msg->data.result != CURLE_GOT_NOTHING))
-                    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                               _("Download of hostlist from `%s' failed: `%s'\n"),
-                               current_url,
-                               curl_easy_strerror(msg->data.result));
-                  else
-                    {
-                      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                                 _("Download of hostlist `%s' completed.\n"),
-                                 current_url);
-                      stat_download_successful = GNUNET_YES;
-                      update_hostlist();
-                      if (GNUNET_YES == stat_testing_hostlist)
-                        {
-                          GNUNET_log(
-                            GNUNET_ERROR_TYPE_INFO,
-                            _("Adding successfully tested hostlist `%s' datastore.\n"),
-                            current_url);
-                          insert_hostlist();
-                          hostlist_to_test = NULL;
-                          stat_testing_hostlist = GNUNET_NO;
-                        }
-                    }
-                  clean_up();
-                  return;
-
-                default:
-                  break;
-                }
+              GNUNET_log (
+                GNUNET_ERROR_TYPE_INFO,
+                _ ("Adding successfully tested hostlist `%s' datastore.\n"),
+                current_url);
+              insert_hostlist ();
+              hostlist_to_test = NULL;
+              stat_testing_hostlist = GNUNET_NO;
             }
-          while ((running > 0));
+          }
+          clean_up ();
+          return;
+
+        default:
+          break;
         }
+      }
+      while ((running > 0));
     }
+  }
   while (mret == CURLM_CALL_MULTI_PERFORM);
 
   if (mret != CURLM_OK)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("%s failed at %s:%d: `%s'\n"),
-                 "curl_multi_perform",
-                 __FILE__,
-                 __LINE__,
-                 curl_multi_strerror(mret));
-      clean_up();
-    }
-  download_prepare();
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_perform",
+                __FILE__,
+                __LINE__,
+                curl_multi_strerror (mret));
+    clean_up ();
+  }
+  download_prepare ();
 }
 
 
@@ -976,133 +977,133 @@ task_download(void *cls)
  * data.
  */
 static void
-download_hostlist()
+download_hostlist ()
 {
   CURLcode ret;
   CURLMcode mret;
 
 
-  current_url = download_get_url();
+  current_url = download_get_url ();
   if (current_url == NULL)
     return;
-  curl = curl_easy_init();
+  curl = curl_easy_init ();
   multi = NULL;
   if (curl == NULL)
-    {
-      GNUNET_break(0);
-      clean_up();
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
-             _("Bootstrapping using hostlist at `%s'.\n"),
-             current_url);
+  {
+    GNUNET_break (0);
+    clean_up ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
+              _ ("Bootstrapping using hostlist at `%s'.\n"),
+              current_url);
 
   stat_download_in_progress = GNUNET_YES;
   stat_download_successful = GNUNET_NO;
   stat_hellos_obtained = 0;
   stat_bytes_downloaded = 0;
 
-  GNUNET_STATISTICS_update(stats,
-                           gettext_noop("# hostlist downloads initiated"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# hostlist downloads initiated"),
+                            1,
+                            GNUNET_NO);
   if (NULL != proxy)
-    {
-      CURL_EASY_SETOPT(curl, CURLOPT_PROXY, proxy);
-      CURL_EASY_SETOPT(curl, CURLOPT_PROXYTYPE, proxy_type);
-      if (NULL != proxy_username)
-        CURL_EASY_SETOPT(curl, CURLOPT_PROXYUSERNAME, proxy_username);
-      if (NULL != proxy_password)
-        CURL_EASY_SETOPT(curl, CURLOPT_PROXYPASSWORD, proxy_password);
-    }
+  {
+    CURL_EASY_SETOPT (curl, CURLOPT_PROXY, proxy);
+    CURL_EASY_SETOPT (curl, CURLOPT_PROXYTYPE, proxy_type);
+    if (NULL != proxy_username)
+      CURL_EASY_SETOPT (curl, CURLOPT_PROXYUSERNAME, proxy_username);
+    if (NULL != proxy_password)
+      CURL_EASY_SETOPT (curl, CURLOPT_PROXYPASSWORD, proxy_password);
+  }
   download_pos = 0;
   stat_bogus_url = 0;
-  CURL_EASY_SETOPT(curl, CURLOPT_WRITEFUNCTION, &callback_download);
+  CURL_EASY_SETOPT (curl, CURLOPT_WRITEFUNCTION, &callback_download);
   if (ret != CURLE_OK)
-    {
-      clean_up();
-      return;
-    }
-  CURL_EASY_SETOPT(curl, CURLOPT_WRITEDATA, NULL);
+  {
+    clean_up ();
+    return;
+  }
+  CURL_EASY_SETOPT (curl, CURLOPT_WRITEDATA, NULL);
   if (ret != CURLE_OK)
-    {
-      clean_up();
-      return;
-    }
-  CURL_EASY_SETOPT(curl, CURLOPT_FOLLOWLOCATION, 1);
-  CURL_EASY_SETOPT(curl,
-                   CURLOPT_REDIR_PROTOCOLS,
-                   CURLPROTO_HTTP | CURLPROTO_HTTPS);
-  CURL_EASY_SETOPT(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
-  CURL_EASY_SETOPT(curl, CURLOPT_MAXREDIRS, 4);
+  {
+    clean_up ();
+    return;
+  }
+  CURL_EASY_SETOPT (curl, CURLOPT_FOLLOWLOCATION, 1);
+  CURL_EASY_SETOPT (curl,
+                    CURLOPT_REDIR_PROTOCOLS,
+                    CURLPROTO_HTTP | CURLPROTO_HTTPS);
+  CURL_EASY_SETOPT (curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+  CURL_EASY_SETOPT (curl, CURLOPT_MAXREDIRS, 4);
   /* no need to abort if the above failed */
-  CURL_EASY_SETOPT(curl, CURLOPT_URL, current_url);
+  CURL_EASY_SETOPT (curl, CURLOPT_URL, current_url);
   if (ret != CURLE_OK)
-    {
-      clean_up();
-      return;
-    }
-  CURL_EASY_SETOPT(curl, CURLOPT_FAILONERROR, 1);
+  {
+    clean_up ();
+    return;
+  }
+  CURL_EASY_SETOPT (curl, CURLOPT_FAILONERROR, 1);
 #if 0
-  CURL_EASY_SETOPT(curl, CURLOPT_VERBOSE, 1);
+  CURL_EASY_SETOPT (curl, CURLOPT_VERBOSE, 1);
 #endif
-  CURL_EASY_SETOPT(curl, CURLOPT_BUFFERSIZE, GNUNET_MAX_MESSAGE_SIZE);
-  if (0 == strncmp(current_url, "http", 4))
-    CURL_EASY_SETOPT(curl, CURLOPT_USERAGENT, "GNUnet");
-  CURL_EASY_SETOPT(curl, CURLOPT_CONNECTTIMEOUT, 60L);
-  CURL_EASY_SETOPT(curl, CURLOPT_TIMEOUT, 60L);
-  multi = curl_multi_init();
+  CURL_EASY_SETOPT (curl, CURLOPT_BUFFERSIZE, GNUNET_MAX_MESSAGE_SIZE);
+  if (0 == strncmp (current_url, "http", 4))
+    CURL_EASY_SETOPT (curl, CURLOPT_USERAGENT, "GNUnet");
+  CURL_EASY_SETOPT (curl, CURLOPT_CONNECTTIMEOUT, 60L);
+  CURL_EASY_SETOPT (curl, CURLOPT_TIMEOUT, 60L);
+  multi = curl_multi_init ();
   if (multi == NULL)
-    {
-      GNUNET_break(0);
-      /* clean_up (); */
-      return;
-    }
-  mret = curl_multi_add_handle(multi, curl);
+  {
+    GNUNET_break (0);
+    /* clean_up (); */
+    return;
+  }
+  mret = curl_multi_add_handle (multi, curl);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("%s failed at %s:%d: `%s'\n"),
-                 "curl_multi_add_handle",
-                 __FILE__,
-                 __LINE__,
-                 curl_multi_strerror(mret));
-      mret = curl_multi_cleanup(multi);
-      if (mret != CURLM_OK)
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                   _("%s failed at %s:%d: `%s'\n"),
-                   "curl_multi_cleanup",
-                   __FILE__,
-                   __LINE__,
-                   curl_multi_strerror(mret));
-      multi = NULL;
-      clean_up();
-      return;
-    }
-  end_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES);
-  download_prepare();
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_add_handle",
+                __FILE__,
+                __LINE__,
+                curl_multi_strerror (mret));
+    mret = curl_multi_cleanup (multi);
+    if (mret != CURLM_OK)
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("%s failed at %s:%d: `%s'\n"),
+                  "curl_multi_cleanup",
+                  __FILE__,
+                  __LINE__,
+                  curl_multi_strerror (mret));
+    multi = NULL;
+    clean_up ();
+    return;
+  }
+  end_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  download_prepare ();
 }
 
 
 static void
-task_download_dispatcher(void *cls)
+task_download_dispatcher (void *cls)
 {
   ti_download_dispatcher_task = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download is initiated...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download is initiated...\n");
   if (GNUNET_NO == stat_download_in_progress)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download can start immediately...\n");
-      download_hostlist();
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download can start immediately...\n");
+    download_hostlist ();
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Download in progess, have to wait...\n");
-      ti_download_dispatcher_task =
-        GNUNET_SCHEDULER_add_delayed(WAITING_INTERVAL,
-                                     &task_download_dispatcher,
-                                     NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Download in progess, have to wait...\n");
+    ti_download_dispatcher_task =
+      GNUNET_SCHEDULER_add_delayed (WAITING_INTERVAL,
+                                    &task_download_dispatcher,
+                                    NULL);
+  }
 }
 
 
@@ -1112,49 +1113,49 @@ task_download_dispatcher(void *cls)
  * this task again for a later time.
  */
 static void
-task_check(void *cls)
+task_check (void *cls)
 {
   static int once;
   struct GNUNET_TIME_Relative delay;
 
   ti_check_download = NULL;
   if (stats == NULL)
-    {
-      curl_global_cleanup();
-      return; /* in shutdown */
-    }
+  {
+    curl_global_cleanup ();
+    return;   /* in shutdown */
+  }
   if ((stat_connection_count < MIN_CONNECTIONS) &&
       (NULL == ti_download_dispatcher_task))
     ti_download_dispatcher_task =
-      GNUNET_SCHEDULER_add_now(&task_download_dispatcher, NULL);
+      GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL);
 
   delay = hostlist_delay;
   if (0 == hostlist_delay.rel_value_us)
     hostlist_delay = GNUNET_TIME_UNIT_SECONDS;
   else
-    hostlist_delay = GNUNET_TIME_relative_multiply(hostlist_delay, 2);
+    hostlist_delay = GNUNET_TIME_relative_multiply (hostlist_delay, 2);
   if (hostlist_delay.rel_value_us >
       GNUNET_TIME_UNIT_HOURS.rel_value_us * (1 + stat_connection_count))
     hostlist_delay =
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS,
-                                    (1 + stat_connection_count));
-  GNUNET_STATISTICS_set(stats,
-                        gettext_noop(
-                          "# milliseconds between hostlist downloads"),
-                        hostlist_delay.rel_value_us / 1000LL,
-                        GNUNET_YES);
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS,
+                                     (1 + stat_connection_count));
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop (
+                           "# milliseconds between hostlist downloads"),
+                         hostlist_delay.rel_value_us / 1000LL,
+                         GNUNET_YES);
   if (0 == once)
-    {
-      delay = GNUNET_TIME_UNIT_ZERO;
-      once = 1;
-    }
-  GNUNET_log(
+  {
+    delay = GNUNET_TIME_UNIT_ZERO;
+    once = 1;
+  }
+  GNUNET_log (
     GNUNET_ERROR_TYPE_INFO,
-    _("Have %u/%u connections.  Will consider downloading hostlist in %s\n"),
+    _ ("Have %u/%u connections.  Will consider downloading hostlist in %s\n"),
     stat_connection_count,
     MIN_CONNECTIONS,
-    GNUNET_STRINGS_relative_time_to_string(delay, GNUNET_YES));
-  ti_check_download = GNUNET_SCHEDULER_add_delayed(delay, &task_check, NULL);
+    GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
+  ti_check_download = GNUNET_SCHEDULER_add_delayed (delay, &task_check, NULL);
 }
 
 
@@ -1164,12 +1165,12 @@ task_check(void *cls)
  * @param cls closure
  */
 static void
-task_testing_intervall_reset(void *cls)
+task_testing_intervall_reset (void *cls)
 {
   ti_testing_intervall_task = NULL;
   stat_testing_allowed = GNUNET_OK;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Testing new hostlist advertisements is allowed again\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testing new hostlist advertisements is allowed again\n");
 }
 
 
@@ -1179,17 +1180,17 @@ task_testing_intervall_reset(void *cls)
  * @param cls closure
  */
 static void
-task_hostlist_saving(void *cls)
+task_hostlist_saving (void *cls)
 {
   ti_saving_task = NULL;
-  save_hostlist_file(GNUNET_NO);
+  save_hostlist_file (GNUNET_NO);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Hostlists will be saved to file again in %s\n",
-             GNUNET_STRINGS_relative_time_to_string(SAVING_INTERVAL,
-                                                    GNUNET_YES));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Hostlists will be saved to file again in %s\n",
+              GNUNET_STRINGS_relative_time_to_string (SAVING_INTERVAL,
+                                                      GNUNET_YES));
   ti_saving_task =
-    GNUNET_SCHEDULER_add_delayed(SAVING_INTERVAL, &task_hostlist_saving, NULL);
+    GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL, &task_hostlist_saving, NULL);
 }
 
 
@@ -1201,16 +1202,16 @@ task_hostlist_saving(void *cls)
  * @param mq message queue for transmissions to @a peer
  */
 static void *
-handler_connect(void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                struct GNUNET_MQ_Handle *mq)
+handler_connect (void *cls,
+                 const struct GNUNET_PeerIdentity *peer,
+                 struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_assert(stat_connection_count < UINT_MAX);
+  GNUNET_assert (stat_connection_count < UINT_MAX);
   stat_connection_count++;
-  GNUNET_STATISTICS_update(stats,
-                           gettext_noop("# active connections"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# active connections"),
+                            1,
+                            GNUNET_NO);
   return NULL;
 }
 
@@ -1222,16 +1223,16 @@ handler_connect(void *cls,
  * @param peer peer identity this notification is about
  */
 static void
-handler_disconnect(void *cls,
-                   const struct GNUNET_PeerIdentity *peer,
-                   void *internal_cls)
+handler_disconnect (void *cls,
+                    const struct GNUNET_PeerIdentity *peer,
+                    void *internal_cls)
 {
-  GNUNET_assert(stat_connection_count > 0);
+  GNUNET_assert (stat_connection_count > 0);
   stat_connection_count--;
-  GNUNET_STATISTICS_update(stats,
-                           gettext_noop("# active connections"),
-                           -1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# active connections"),
+                            -1,
+                            GNUNET_NO);
 }
 
 
@@ -1241,57 +1242,57 @@ handler_disconnect(void *cls,
  * @param uri the advertised URI
  */
 static void
-handler_advertisement(const char *uri)
+handler_advertisement (const char *uri)
 {
   size_t uri_size;
   struct Hostlist *hostlist;
 
-  uri_size = strlen(uri) + 1;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Hostlist client recieved advertisement containing URI `%s'\n",
-             uri);
-  if (GNUNET_NO != linked_list_contains(uri))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri);
-      return;
-    }
+  uri_size = strlen (uri) + 1;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Hostlist client recieved advertisement containing URI `%s'\n",
+              uri);
+  if (GNUNET_NO != linked_list_contains (uri))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri);
+    return;
+  }
 
   if (GNUNET_NO == stat_testing_allowed)
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_DEBUG,
-        "Currently not accepting new advertisements: interval between to advertisements is not reached\n");
-      return;
-    }
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Currently not accepting new advertisements: interval between to advertisements is not reached\n");
+    return;
+  }
   if (GNUNET_YES == stat_testing_hostlist)
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_DEBUG,
-        "Currently not accepting new advertisements: we are already testing a hostlist\n");
-      return;
-    }
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Currently not accepting new advertisements: we are already testing a hostlist\n");
+    return;
+  }
 
-  hostlist = GNUNET_malloc(sizeof(struct Hostlist) + uri_size);
-  hostlist->hostlist_uri = (const char *)&hostlist[1];
-  GNUNET_memcpy(&hostlist[1], uri, uri_size);
-  hostlist->time_creation = GNUNET_TIME_absolute_get();
+  hostlist = GNUNET_malloc (sizeof(struct Hostlist) + uri_size);
+  hostlist->hostlist_uri = (const char *) &hostlist[1];
+  GNUNET_memcpy (&hostlist[1], uri, uri_size);
+  hostlist->time_creation = GNUNET_TIME_absolute_get ();
   hostlist->quality = HOSTLIST_INITIAL;
   hostlist_to_test = hostlist;
 
   stat_testing_hostlist = GNUNET_YES;
   stat_testing_allowed = GNUNET_NO;
   ti_testing_intervall_task =
-    GNUNET_SCHEDULER_add_delayed(TESTING_INTERVAL,
-                                 &task_testing_intervall_reset,
-                                 NULL);
+    GNUNET_SCHEDULER_add_delayed (TESTING_INTERVAL,
+                                  &task_testing_intervall_reset,
+                                  NULL);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Testing new hostlist advertisements is locked for the next %s\n",
-             GNUNET_STRINGS_relative_time_to_string(TESTING_INTERVAL,
-                                                    GNUNET_YES));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testing new hostlist advertisements is locked for the next %s\n",
+              GNUNET_STRINGS_relative_time_to_string (TESTING_INTERVAL,
+                                                      GNUNET_YES));
 
   ti_download_dispatcher_task =
-    GNUNET_SCHEDULER_add_now(&task_download_dispatcher, NULL);
+    GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL);
 }
 
 
@@ -1304,18 +1305,18 @@ handler_advertisement(const char *uri)
  *        successfully obtained, #GNUNET_SYSERR if not.
  */
 static void
-primary_task(void *cls, int success)
+primary_task (void *cls, int success)
 {
   if (NULL != ti_check_download)
-    {
-      GNUNET_SCHEDULER_cancel(ti_check_download);
-      ti_check_download = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_check_download);
+    ti_check_download = NULL;
+  }
   sget = NULL;
-  GNUNET_assert(NULL != stats);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Statistics request done, scheduling hostlist download\n");
-  ti_check_download = GNUNET_SCHEDULER_add_now(&task_check, NULL);
+  GNUNET_assert (NULL != stats);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Statistics request done, scheduling hostlist download\n");
+  ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL);
 }
 
 
@@ -1328,11 +1329,11 @@ primary_task(void *cls, int success)
  *        successfully obtained, #GNUNET_SYSERR if not.
  */
 static void
-stat_timeout_task(void *cls)
+stat_timeout_task (void *cls)
 {
-  GNUNET_STATISTICS_get_cancel(sget);
+  GNUNET_STATISTICS_get_cancel (sget);
   sget = NULL;
-  ti_check_download = GNUNET_SCHEDULER_add_now(&task_check, NULL);
+  ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL);
 }
 
 
@@ -1346,17 +1347,17 @@ stat_timeout_task(void *cls)
  * @param is_persistent unused, will be #GNUNET_YES
  */
 static int
-process_stat(void *cls,
-             const char *subsystem,
-             const char *name,
-             uint64_t value,
-             int is_persistent)
+process_stat (void *cls,
+              const char *subsystem,
+              const char *name,
+              uint64_t value,
+              int is_persistent)
 {
   hostlist_delay.rel_value_us = value * 1000LL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Initial time between hostlist downloads is %s\n",
-             GNUNET_STRINGS_relative_time_to_string(hostlist_delay,
-                                                    GNUNET_YES));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initial time between hostlist downloads is %s\n",
+              GNUNET_STRINGS_relative_time_to_string (hostlist_delay,
+                                                      GNUNET_YES));
   return GNUNET_OK;
 }
 
@@ -1365,7 +1366,7 @@ process_stat(void *cls,
  * Method to load persistent hostlist file during hostlist client startup
  */
 static void
-load_hostlist_file()
+load_hostlist_file ()
 {
   char *filename;
   char *uri;
@@ -1380,87 +1381,87 @@ load_hostlist_file()
   struct GNUNET_BIO_ReadHandle *rh;
 
   uri = NULL;
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                                           "HOSTLIST",
-                                                           "HOSTLISTFILE",
-                                                           &filename))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING,
-                                "hostlist",
-                                "HOSTLISTFILE");
-      return;
-    }
-
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("Loading saved hostlist entries from file `%s' \n"),
-             filename);
-  if (GNUNET_NO == GNUNET_DISK_file_test(filename))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("Hostlist file `%s' does not exist\n"),
-                 filename);
-      GNUNET_free(filename);
-      return;
-    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                            "HOSTLIST",
+                                                            "HOSTLISTFILE",
+                                                            &filename))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+                               "hostlist",
+                               "HOSTLISTFILE");
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Loading saved hostlist entries from file `%s' \n"),
+              filename);
+  if (GNUNET_NO == GNUNET_DISK_file_test (filename))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Hostlist file `%s' does not exist\n"),
+                filename);
+    GNUNET_free (filename);
+    return;
+  }
 
-  rh = GNUNET_BIO_read_open(filename);
+  rh = GNUNET_BIO_read_open (filename);
   if (NULL == rh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _(
-                   "Could not open file `%s' for reading to load hostlists: %s\n"),
-                 filename,
-                 strerror(errno));
-      GNUNET_free(filename);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ (
+                  "Could not open file `%s' for reading to load hostlists: %s\n"),
+                filename,
+                strerror (errno));
+    GNUNET_free (filename);
+    return;
+  }
 
   counter = 0;
-  while ((GNUNET_OK == GNUNET_BIO_read_string(rh, "url", &uri, MAX_URL_LEN)) &&
+  while ((GNUNET_OK == GNUNET_BIO_read_string (rh, "url", &uri, MAX_URL_LEN)) &&
          (NULL != uri) &&
-         (GNUNET_OK == GNUNET_BIO_read_int32(rh, &times_used)) &&
-         (GNUNET_OK == GNUNET_BIO_read_int64(rh, &quality)) &&
-         (GNUNET_OK == GNUNET_BIO_read_int64(rh, &last_used)) &&
-         (GNUNET_OK == GNUNET_BIO_read_int64(rh, &created)) &&
-         (GNUNET_OK == GNUNET_BIO_read_int32(rh, &hellos_returned)))
-    {
-      hostlist = GNUNET_malloc(sizeof(struct Hostlist) + strlen(uri) + 1);
-      hostlist->hello_count = hellos_returned;
-      hostlist->hostlist_uri = (const char *)&hostlist[1];
-      GNUNET_memcpy(&hostlist[1], uri, strlen(uri) + 1);
-      hostlist->quality = quality;
-      hostlist->time_creation.abs_value_us = created;
-      hostlist->time_last_usage.abs_value_us = last_used;
-      GNUNET_CONTAINER_DLL_insert(linked_list_head, linked_list_tail, hostlist);
-      linked_list_size++;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Added hostlist entry eith URI `%s' \n",
-                 hostlist->hostlist_uri);
-      GNUNET_free(uri);
-      uri = NULL;
-      counter++;
-      if (counter >= MAX_NUMBER_HOSTLISTS)
-        break;
-    }
-
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("%u hostlist URIs loaded from file\n"),
-             counter);
-  GNUNET_STATISTICS_set(stats,
-                        gettext_noop("# hostlist URIs read from file"),
-                        counter,
-                        GNUNET_YES);
-  GNUNET_STATISTICS_set(stats,
-                        gettext_noop("# advertised hostlist URIs"),
-                        linked_list_size,
-                        GNUNET_NO);
-
-  GNUNET_free_non_null(uri);
+         (GNUNET_OK == GNUNET_BIO_read_int32 (rh, &times_used)) &&
+         (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &quality)) &&
+         (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &last_used)) &&
+         (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &created)) &&
+         (GNUNET_OK == GNUNET_BIO_read_int32 (rh, &hellos_returned)))
+  {
+    hostlist = GNUNET_malloc (sizeof(struct Hostlist) + strlen (uri) + 1);
+    hostlist->hello_count = hellos_returned;
+    hostlist->hostlist_uri = (const char *) &hostlist[1];
+    GNUNET_memcpy (&hostlist[1], uri, strlen (uri) + 1);
+    hostlist->quality = quality;
+    hostlist->time_creation.abs_value_us = created;
+    hostlist->time_last_usage.abs_value_us = last_used;
+    GNUNET_CONTAINER_DLL_insert (linked_list_head, linked_list_tail, hostlist);
+    linked_list_size++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Added hostlist entry eith URI `%s' \n",
+                hostlist->hostlist_uri);
+    GNUNET_free (uri);
+    uri = NULL;
+    counter++;
+    if (counter >= MAX_NUMBER_HOSTLISTS)
+      break;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("%u hostlist URIs loaded from file\n"),
+              counter);
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop ("# hostlist URIs read from file"),
+                         counter,
+                         GNUNET_YES);
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop ("# advertised hostlist URIs"),
+                         linked_list_size,
+                         GNUNET_NO);
+
+  GNUNET_free_non_null (uri);
   emsg = NULL;
-  (void)GNUNET_BIO_read_close(rh, &emsg);
+  (void) GNUNET_BIO_read_close (rh, &emsg);
   if (emsg != NULL)
-    GNUNET_free(emsg);
-  GNUNET_free(filename);
+    GNUNET_free (emsg);
+  GNUNET_free (filename);
 }
 
 
@@ -1470,7 +1471,7 @@ load_hostlist_file()
  * @param shutdown set if called because of shutdown, entries in linked list will be destroyed
  */
 static void
-save_hostlist_file(int shutdown)
+save_hostlist_file (int shutdown)
 {
   char *filename;
   struct Hostlist *pos;
@@ -1478,80 +1479,80 @@ save_hostlist_file(int shutdown)
   int ok;
   uint32_t counter;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                                           "HOSTLIST",
-                                                           "HOSTLISTFILE",
-                                                           &filename))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING,
-                                "hostlist",
-                                "HOSTLISTFILE");
-      return;
-    }
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file(filename))
-    {
-      GNUNET_free(filename);
-      return;
-    }
-  wh = GNUNET_BIO_write_open(filename);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                            "HOSTLIST",
+                                                            "HOSTLISTFILE",
+                                                            &filename))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+                               "hostlist",
+                               "HOSTLISTFILE");
+    return;
+  }
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
+  {
+    GNUNET_free (filename);
+    return;
+  }
+  wh = GNUNET_BIO_write_open (filename);
   if (NULL == wh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _(
-                   "Could not open file `%s' for writing to save hostlists: %s\n"),
-                 filename,
-                 strerror(errno));
-      GNUNET_free(filename);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("Writing %u hostlist URIs to `%s'\n"),
-             linked_list_size,
-             filename);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "Could not open file `%s' for writing to save hostlists: %s\n"),
+                filename,
+                strerror (errno));
+    GNUNET_free (filename);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Writing %u hostlist URIs to `%s'\n"),
+              linked_list_size,
+              filename);
   /* add code to write hostlists to file using bio */
   ok = GNUNET_YES;
   counter = 0;
   while (NULL != (pos = linked_list_head))
+  {
+    if (GNUNET_YES == shutdown)
     {
-      if (GNUNET_YES == shutdown)
-        {
-          GNUNET_CONTAINER_DLL_remove(linked_list_head, linked_list_tail, pos);
-          linked_list_size--;
-        }
-      if (GNUNET_YES == ok)
-        {
-          if ((GNUNET_OK != GNUNET_BIO_write_string(wh, pos->hostlist_uri)) ||
-              (GNUNET_OK != GNUNET_BIO_write_int32(wh, pos->times_used)) ||
-              (GNUNET_OK != GNUNET_BIO_write_int64(wh, pos->quality)) ||
-              (GNUNET_OK !=
-               GNUNET_BIO_write_int64(wh, pos->time_last_usage.abs_value_us)) ||
-              (GNUNET_OK !=
-               GNUNET_BIO_write_int64(wh, pos->time_creation.abs_value_us)) ||
-              (GNUNET_OK != GNUNET_BIO_write_int32(wh, pos->hello_count)))
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                         _("Error writing hostlist URIs to file `%s'\n"),
-                         filename);
-              ok = GNUNET_NO;
-            }
-        }
-
-      if (GNUNET_YES == shutdown)
-        GNUNET_free(pos);
-      counter++;
-      if (counter >= MAX_NUMBER_HOSTLISTS)
-        break;
+      GNUNET_CONTAINER_DLL_remove (linked_list_head, linked_list_tail, pos);
+      linked_list_size--;
+    }
+    if (GNUNET_YES == ok)
+    {
+      if ((GNUNET_OK != GNUNET_BIO_write_string (wh, pos->hostlist_uri)) ||
+          (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pos->times_used)) ||
+          (GNUNET_OK != GNUNET_BIO_write_int64 (wh, pos->quality)) ||
+          (GNUNET_OK !=
+           GNUNET_BIO_write_int64 (wh, pos->time_last_usage.abs_value_us)) ||
+          (GNUNET_OK !=
+           GNUNET_BIO_write_int64 (wh, pos->time_creation.abs_value_us)) ||
+          (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pos->hello_count)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _ ("Error writing hostlist URIs to file `%s'\n"),
+                    filename);
+        ok = GNUNET_NO;
+      }
     }
-  GNUNET_STATISTICS_set(stats,
-                        gettext_noop("# hostlist URIs written to file"),
-                        counter,
-                        GNUNET_YES);
-
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-               _("Error writing hostlist URIs to file `%s'\n"),
-               filename);
-  GNUNET_free(filename);
+
+    if (GNUNET_YES == shutdown)
+      GNUNET_free (pos);
+    counter++;
+    if (counter >= MAX_NUMBER_HOSTLISTS)
+      break;
+  }
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop ("# hostlist URIs written to file"),
+                         counter,
+                         GNUNET_YES);
+
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Error writing hostlist URIs to file `%s'\n"),
+                filename);
+  GNUNET_free (filename);
 }
 
 
@@ -1567,94 +1568,94 @@ save_hostlist_file(int shutdown)
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c,
-                             struct GNUNET_STATISTICS_Handle *st,
-                             GNUNET_CORE_ConnectEventHandler *ch,
-                             GNUNET_CORE_DisconnectEventHandler *dh,
-                             GNUNET_HOSTLIST_UriHandler *msgh,
-                             int learn)
+GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c,
+                              struct GNUNET_STATISTICS_Handle *st,
+                              GNUNET_CORE_ConnectEventHandler *ch,
+                              GNUNET_CORE_DisconnectEventHandler *dh,
+                              GNUNET_HOSTLIST_UriHandler *msgh,
+                              int learn)
 {
   char *filename;
   char *proxytype_str;
   int result;
 
-  GNUNET_assert(NULL != st);
-  if (0 != curl_global_init(CURL_GLOBAL_WIN32))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  GNUNET_assert (NULL != st);
+  if (0 != curl_global_init (CURL_GLOBAL_WIN32))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   cfg = c;
   stats = st;
 
   /* Read proxy configuration */
-  pi = GNUNET_PEERINFO_connect(c);
+  pi = GNUNET_PEERINFO_connect (c);
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_string(cfg, "HOSTLIST", "PROXY", &proxy))
+      GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST", "PROXY", &proxy))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found proxy host: `%s'\n", proxy);
+    /* proxy username */
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                            "HOSTLIST",
+                                                            "PROXY_USERNAME",
+                                                            &proxy_username))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found proxy host: `%s'\n", proxy);
-      /* proxy username */
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             "HOSTLIST",
-                                                             "PROXY_USERNAME",
-                                                             &proxy_username))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Found proxy username name: `%s'\n",
-                     proxy_username);
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Found proxy username name: `%s'\n",
+                  proxy_username);
+    }
 
-      /* proxy password */
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             "HOSTLIST",
-                                                             "PROXY_PASSWORD",
-                                                             &proxy_password))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Found proxy password name: `%s'\n",
-                     proxy_password);
-        }
+    /* proxy password */
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                            "HOSTLIST",
+                                                            "PROXY_PASSWORD",
+                                                            &proxy_password))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Found proxy password name: `%s'\n",
+                  proxy_password);
+    }
 
-      /* proxy type */
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             "HOSTLIST",
-                                                             "PROXY_TYPE",
-                                                             &proxytype_str))
-        {
-          GNUNET_STRINGS_utf8_toupper(proxytype_str, proxytype_str);
-          proxy_type = CURLPROXY_HTTP;
-          if (0 == strcmp(proxytype_str, "HTTP"))
-            proxy_type = CURLPROXY_HTTP;
-          else if (0 == strcmp(proxytype_str, "HTTP_1_0"))
-            proxy_type = CURLPROXY_HTTP_1_0;
-          else if (0 == strcmp(proxytype_str, "SOCKS4"))
-            proxy_type = CURLPROXY_SOCKS4;
-          else if (0 == strcmp(proxytype_str, "SOCKS5"))
-            proxy_type = CURLPROXY_SOCKS5;
-          else if (0 == strcmp(proxytype_str, "SOCKS4A"))
-            proxy_type = CURLPROXY_SOCKS4A;
-          else if (0 == strcmp(proxytype_str, "SOCKS5_HOSTNAME"))
-            proxy_type = CURLPROXY_SOCKS5_HOSTNAME;
-          else
-            {
-              GNUNET_log(
-                GNUNET_ERROR_TYPE_ERROR,
-                _(
-                  "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"),
-                proxytype_str);
-              GNUNET_free(proxytype_str);
-              GNUNET_free(proxy);
-              proxy = NULL;
-              GNUNET_free_non_null(proxy_username);
-              proxy_username = NULL;
-              GNUNET_free_non_null(proxy_password);
-              proxy_password = NULL;
-
-              return GNUNET_SYSERR;
-            }
-        }
-      GNUNET_free_non_null(proxytype_str);
+    /* proxy type */
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                            "HOSTLIST",
+                                                            "PROXY_TYPE",
+                                                            &proxytype_str))
+    {
+      GNUNET_STRINGS_utf8_toupper (proxytype_str, proxytype_str);
+      proxy_type = CURLPROXY_HTTP;
+      if (0 == strcmp (proxytype_str, "HTTP"))
+        proxy_type = CURLPROXY_HTTP;
+      else if (0 == strcmp (proxytype_str, "HTTP_1_0"))
+        proxy_type = CURLPROXY_HTTP_1_0;
+      else if (0 == strcmp (proxytype_str, "SOCKS4"))
+        proxy_type = CURLPROXY_SOCKS4;
+      else if (0 == strcmp (proxytype_str, "SOCKS5"))
+        proxy_type = CURLPROXY_SOCKS5;
+      else if (0 == strcmp (proxytype_str, "SOCKS4A"))
+        proxy_type = CURLPROXY_SOCKS4A;
+      else if (0 == strcmp (proxytype_str, "SOCKS5_HOSTNAME"))
+        proxy_type = CURLPROXY_SOCKS5_HOSTNAME;
+      else
+      {
+        GNUNET_log (
+          GNUNET_ERROR_TYPE_ERROR,
+          _ (
+            "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"),
+          proxytype_str);
+        GNUNET_free (proxytype_str);
+        GNUNET_free (proxy);
+        proxy = NULL;
+        GNUNET_free_non_null (proxy_username);
+        proxy_username = NULL;
+        GNUNET_free_non_null (proxy_password);
+        proxy_password = NULL;
+
+        return GNUNET_SYSERR;
+      }
     }
+    GNUNET_free_non_null (proxytype_str);
+  }
 
   stat_learning = learn;
   *ch = &handler_connect;
@@ -1666,67 +1667,67 @@ GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c,
   stat_testing_allowed = GNUNET_YES;
 
   if (GNUNET_YES == stat_learning)
-    {
-      *msgh = &handler_advertisement;
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("Learning is enabled on this peer\n"));
-      load_hostlist_file();
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Hostlists will be saved to file again in %s\n",
-                 GNUNET_STRINGS_relative_time_to_string(SAVING_INTERVAL,
+  {
+    *msgh = &handler_advertisement;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Learning is enabled on this peer\n"));
+    load_hostlist_file ();
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Hostlists will be saved to file again in %s\n",
+                GNUNET_STRINGS_relative_time_to_string (SAVING_INTERVAL,
                                                         GNUNET_YES));
-      ti_saving_task = GNUNET_SCHEDULER_add_delayed(SAVING_INTERVAL,
-                                                    &task_hostlist_saving,
-                                                    NULL);
-    }
+    ti_saving_task = GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL,
+                                                   &task_hostlist_saving,
+                                                   NULL);
+  }
   else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Learning is not enabled on this peer\n"));
+    *msgh = NULL;
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                              "HOSTLIST",
+                                                              "HOSTLISTFILE",
+                                                              &filename))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("Learning is not enabled on this peer\n"));
-      *msgh = NULL;
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                                               "HOSTLIST",
-                                                               "HOSTLISTFILE",
-                                                               &filename))
-        {
-          if (GNUNET_YES == GNUNET_DISK_file_test(filename))
-            {
-              result = remove(filename);
-              if (0 == result)
-                GNUNET_log(
-                  GNUNET_ERROR_TYPE_INFO,
-                  _(
-                    "Since learning is not enabled on this peer, hostlist file `%s' was removed\n"),
-                  filename);
-              else
-                GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
-                                         "remove",
-                                         filename);
-            }
-        }
-      GNUNET_free(filename);
+      if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+      {
+        result = remove (filename);
+        if (0 == result)
+          GNUNET_log (
+            GNUNET_ERROR_TYPE_INFO,
+            _ (
+              "Since learning is not enabled on this peer, hostlist file `%s' was removed\n"),
+            filename);
+        else
+          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                                    "remove",
+                                    filename);
+      }
     }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Loading stats value on hostlist download frequency\n");
-  sget = GNUNET_STATISTICS_get(stats,
-                               "hostlist",
-                               gettext_noop(
-                                 "# milliseconds between hostlist downloads"),
-                               &primary_task,
-                               &process_stat,
-                               NULL);
+    GNUNET_free (filename);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Loading stats value on hostlist download frequency\n");
+  sget = GNUNET_STATISTICS_get (stats,
+                                "hostlist",
+                                gettext_noop (
+                                  "# milliseconds between hostlist downloads"),
+                                &primary_task,
+                                &process_stat,
+                                NULL);
   if (NULL == sget)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Statistics request failed, scheduling hostlist download\n");
-      ti_check_download = GNUNET_SCHEDULER_add_now(&task_check, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Statistics request failed, scheduling hostlist download\n");
+    ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL);
+  }
   else
-    {
-      ti_check_download = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
-                                                       &stat_timeout_task,
-                                                       NULL);
-    }
+  {
+    ti_check_download = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                                      &stat_timeout_task,
+                                                      NULL);
+  }
   return GNUNET_OK;
 }
 
@@ -1735,56 +1736,56 @@ GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c,
  * Stop downloading hostlists from hostlist servers as necessary.
  */
 void
-GNUNET_HOSTLIST_client_stop()
+GNUNET_HOSTLIST_client_stop ()
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n");
   if (NULL != sget)
-    {
-      GNUNET_STATISTICS_get_cancel(sget);
-      sget = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (sget);
+    sget = NULL;
+  }
   stats = NULL;
   if (GNUNET_YES == stat_learning)
-    save_hostlist_file(GNUNET_YES);
+    save_hostlist_file (GNUNET_YES);
   if (NULL != ti_saving_task)
-    {
-      GNUNET_SCHEDULER_cancel(ti_saving_task);
-      ti_saving_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_saving_task);
+    ti_saving_task = NULL;
+  }
   if (NULL != ti_download_dispatcher_task)
-    {
-      GNUNET_SCHEDULER_cancel(ti_download_dispatcher_task);
-      ti_download_dispatcher_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_download_dispatcher_task);
+    ti_download_dispatcher_task = NULL;
+  }
   if (NULL != ti_testing_intervall_task)
-    {
-      GNUNET_SCHEDULER_cancel(ti_testing_intervall_task);
-      ti_testing_intervall_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_testing_intervall_task);
+    ti_testing_intervall_task = NULL;
+  }
   if (NULL != ti_download)
-    {
-      GNUNET_SCHEDULER_cancel(ti_download);
-      ti_download = NULL;
-      update_hostlist();
-      clean_up();
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_download);
+    ti_download = NULL;
+    update_hostlist ();
+    clean_up ();
+  }
   if (NULL != ti_check_download)
-    {
-      GNUNET_SCHEDULER_cancel(ti_check_download);
-      ti_check_download = NULL;
-      curl_global_cleanup();
-    }
-  GNUNET_free_non_null(proxy);
+  {
+    GNUNET_SCHEDULER_cancel (ti_check_download);
+    ti_check_download = NULL;
+    curl_global_cleanup ();
+  }
+  GNUNET_free_non_null (proxy);
   proxy = NULL;
-  GNUNET_free_non_null(proxy_username);
+  GNUNET_free_non_null (proxy_username);
   proxy_username = NULL;
-  GNUNET_free_non_null(proxy_password);
+  GNUNET_free_non_null (proxy_password);
   proxy_password = NULL;
   if (NULL != pi)
-    {
-      GNUNET_PEERINFO_disconnect(pi);
-      pi = NULL;
-    }
+  {
+    GNUNET_PEERINFO_disconnect (pi);
+    pi = NULL;
+  }
   cfg = NULL;
 }
 
diff --git a/src/hostlist/gnunet-daemon-hostlist_client.h b/src/hostlist/gnunet-daemon-hostlist_client.h
index 4268b26dd..2ee40d961 100644
--- a/src/hostlist/gnunet-daemon-hostlist_client.h
+++ b/src/hostlist/gnunet-daemon-hostlist_client.h
@@ -51,19 +51,19 @@ typedef void
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_HOSTLIST_client_start(const struct GNUNET_CONFIGURATION_Handle *c,
-                             struct GNUNET_STATISTICS_Handle *st,
-                             GNUNET_CORE_ConnectEventHandler *ch,
-                             GNUNET_CORE_DisconnectEventHandler *dh,
-                             GNUNET_HOSTLIST_UriHandler *msgh,
-                             int learn);
+GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c,
+                              struct GNUNET_STATISTICS_Handle *st,
+                              GNUNET_CORE_ConnectEventHandler *ch,
+                              GNUNET_CORE_DisconnectEventHandler *dh,
+                              GNUNET_HOSTLIST_UriHandler *msgh,
+                              int learn);
 
 
 /**
  * Stop downloading hostlists from hostlist servers as necessary.
  */
 void
-GNUNET_HOSTLIST_client_stop(void);
+GNUNET_HOSTLIST_client_stop (void);
 
 
 #endif
diff --git a/src/hostlist/gnunet-daemon-hostlist_server.c b/src/hostlist/gnunet-daemon-hostlist_server.c
index b4e0df34e..43513930a 100644
--- a/src/hostlist/gnunet-daemon-hostlist_server.c
+++ b/src/hostlist/gnunet-daemon-hostlist_server.c
@@ -39,7 +39,7 @@
  * time out?
  */
 #define GNUNET_ADV_TIMEOUT \
-  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
 
 
 /**
@@ -106,7 +106,8 @@ static char *hostlist_uri;
 /**
  * Context for #host_processor().
  */
-struct HostSet {
+struct HostSet
+{
   /**
    * Iterator used to build @e data (NULL when done).
    */
@@ -137,13 +138,13 @@ static struct HostSet *builder;
  * @param response response to add headers to
  */
 static void
-add_cors_headers(struct MHD_Response *response)
+add_cors_headers (struct MHD_Response *response)
 {
-  MHD_add_response_header(response, "Access-Control-Allow-Origin", "*");
-  MHD_add_response_header(response,
-                          "Access-Control-Allow-Methods",
-                          "GET, OPTIONS");
-  MHD_add_response_header(response, "Access-Control-Max-Age", "86400");
+  MHD_add_response_header (response, "Access-Control-Allow-Origin", "*");
+  MHD_add_response_header (response,
+                           "Access-Control-Allow-Methods",
+                           "GET, OPTIONS");
+  MHD_add_response_header (response, "Access-Control-Max-Age", "86400");
 }
 
 
@@ -151,27 +152,27 @@ add_cors_headers(struct MHD_Response *response)
  * Function that assembles our response.
  */
 static void
-finish_response()
+finish_response ()
 {
   if (NULL != response)
-    MHD_destroy_response(response);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Creating hostlist response with %u bytes\n",
-             (unsigned int)builder->size);
-  response = MHD_create_response_from_buffer(builder->size,
-                                             builder->data,
-                                             MHD_RESPMEM_MUST_FREE);
-  add_cors_headers(response);
+    MHD_destroy_response (response);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating hostlist response with %u bytes\n",
+              (unsigned int) builder->size);
+  response = MHD_create_response_from_buffer (builder->size,
+                                              builder->data,
+                                              MHD_RESPMEM_MUST_FREE);
+  add_cors_headers (response);
   if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6))
-    {
-      MHD_destroy_response(response);
-      response = NULL;
-    }
-  GNUNET_STATISTICS_set(stats,
-                        gettext_noop("bytes in hostlist"),
-                        builder->size,
-                        GNUNET_YES);
-  GNUNET_free(builder);
+  {
+    MHD_destroy_response (response);
+    response = NULL;
+  }
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop ("bytes in hostlist"),
+                         builder->size,
+                         GNUNET_YES);
+  GNUNET_free (builder);
   builder = NULL;
 }
 
@@ -185,20 +186,20 @@ finish_response()
  * @return  #GNUNET_SYSERR to stop iterating (unless expiration has occured)
  */
 static int
-check_has_addr(void *cls,
-               const struct GNUNET_HELLO_Address *address,
-               struct GNUNET_TIME_Absolute expiration)
+check_has_addr (void *cls,
+                const struct GNUNET_HELLO_Address *address,
+                struct GNUNET_TIME_Absolute expiration)
 {
   int *arg = cls;
 
-  if (0 == GNUNET_TIME_absolute_get_remaining(expiration).rel_value_us)
-    {
-      GNUNET_STATISTICS_update(stats,
-                               gettext_noop("expired addresses encountered"),
-                               1,
-                               GNUNET_YES);
-      return GNUNET_YES; /* ignore this address */
-    }
+  if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("expired addresses encountered"),
+                              1,
+                              GNUNET_YES);
+    return GNUNET_YES;   /* ignore this address */
+  }
   *arg = GNUNET_YES;
   return GNUNET_SYSERR;
 }
@@ -214,73 +215,73 @@ check_has_addr(void *cls,
  * @param err_msg message
  */
 static void
-host_processor(void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               const struct GNUNET_HELLO_Message *hello,
-               const char *err_msg)
+host_processor (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_HELLO_Message *hello,
+                const char *err_msg)
 {
   size_t old;
   size_t s;
   int has_addr;
 
   if (NULL != err_msg)
-    {
-      GNUNET_assert(NULL == peer);
-      builder->pitr = NULL;
-      GNUNET_free_non_null(builder->data);
-      GNUNET_free(builder);
-      builder = NULL;
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("Error in communication with PEERINFO service: %s\n"),
-                 err_msg);
-      return;
-    }
+  {
+    GNUNET_assert (NULL == peer);
+    builder->pitr = NULL;
+    GNUNET_free_non_null (builder->data);
+    GNUNET_free (builder);
+    builder = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Error in communication with PEERINFO service: %s\n"),
+                err_msg);
+    return;
+  }
   if (NULL == peer)
-    {
-      builder->pitr = NULL;
-      finish_response();
-      return;
-    }
+  {
+    builder->pitr = NULL;
+    finish_response ();
+    return;
+  }
   if (NULL == hello)
     return;
   has_addr = GNUNET_NO;
-  GNUNET_HELLO_iterate_addresses(hello, GNUNET_NO, &check_has_addr, &has_addr);
+  GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_has_addr, &has_addr);
   if (GNUNET_NO == has_addr)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "HELLO for peer `%4s' has no address, not suitable for hostlist!\n",
-                 GNUNET_i2s(peer));
-      GNUNET_STATISTICS_update(stats,
-                               gettext_noop(
-                                 "HELLOs without addresses encountered (ignored)"),
-                               1,
-                               GNUNET_NO);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "HELLO for peer `%4s' has no address, not suitable for hostlist!\n",
+                GNUNET_i2s (peer));
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop (
+                                "HELLOs without addresses encountered (ignored)"),
+                              1,
+                              GNUNET_NO);
+    return;
+  }
   old = builder->size;
-  s = GNUNET_HELLO_size(hello);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
-             (unsigned int)s,
-             "HELLO",
-             GNUNET_i2s(peer));
+  s = GNUNET_HELLO_size (hello);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
+              (unsigned int) s,
+              "HELLO",
+              GNUNET_i2s (peer));
   if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) ||
       (old + s >= MAX_BYTES_PER_HOSTLISTS))
-    {
-      /* too large, skip! */
-      GNUNET_STATISTICS_update(stats,
-                               gettext_noop(
-                                 "bytes not included in hostlist (size limit)"),
-                               s,
-                               GNUNET_NO);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Adding peer `%s' to hostlist (%u bytes)\n",
-             GNUNET_i2s(peer),
-             (unsigned int)s);
-  GNUNET_array_grow(builder->data, builder->size, old + s);
-  GNUNET_memcpy(&builder->data[old], hello, s);
+  {
+    /* too large, skip! */
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop (
+                                "bytes not included in hostlist (size limit)"),
+                              s,
+                              GNUNET_NO);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Adding peer `%s' to hostlist (%u bytes)\n",
+              GNUNET_i2s (peer),
+              (unsigned int) s);
+  GNUNET_array_grow (builder->data, builder->size, old + s);
+  GNUNET_memcpy (&builder->data[old], hello, s);
 }
 
 
@@ -294,17 +295,17 @@ host_processor(void *cls,
  * @return #MHD_YES if connection is allowed, #MHD_NO if not (we are not ready)
  */
 static int
-accept_policy_callback(void *cls,
-                       const struct sockaddr *addr,
-                       socklen_t addrlen)
+accept_policy_callback (void *cls,
+                        const struct sockaddr *addr,
+                        socklen_t addrlen)
 {
   if (NULL == response)
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_DEBUG,
-        "Received request for hostlist, but I am not yet ready; rejecting!\n");
-      return MHD_NO;
-    }
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Received request for hostlist, but I am not yet ready; rejecting!\n");
+    return MHD_NO;
+  }
   return MHD_YES; /* accept all */
 }
 
@@ -345,80 +346,80 @@ accept_policy_callback(void *cls,
  *         error while handling the request
  */
 static int
-access_handler_callback(void *cls,
-                        struct MHD_Connection *connection,
-                        const char *url,
-                        const char *method,
-                        const char *version,
-                        const char *upload_data,
-                        size_t *upload_data_size,
-                        void **con_cls)
+access_handler_callback (void *cls,
+                         struct MHD_Connection *connection,
+                         const char *url,
+                         const char *method,
+                         const char *version,
+                         const char *upload_data,
+                         size_t *upload_data_size,
+                         void **con_cls)
 {
   static int dummy;
 
   /* CORS pre-flight request */
-  if (0 == strcmp(MHD_HTTP_METHOD_OPTIONS, method))
-    {
-      struct MHD_Response *options_response;
-      int rc;
-
-      options_response =
-        MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT);
-      add_cors_headers(options_response);
-      rc = MHD_queue_response(connection, MHD_HTTP_OK, options_response);
-      MHD_destroy_response(options_response);
-      return rc;
-    }
-  if (0 != strcmp(method, MHD_HTTP_METHOD_GET))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Refusing `%s' request to hostlist server\n"),
-                 method);
-      GNUNET_STATISTICS_update(stats,
-                               gettext_noop(
-                                 "hostlist requests refused (not HTTP GET)"),
-                               1,
-                               GNUNET_YES);
-      return MHD_NO;
-    }
+  if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method))
+  {
+    struct MHD_Response *options_response;
+    int rc;
+
+    options_response =
+      MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT);
+    add_cors_headers (options_response);
+    rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response);
+    MHD_destroy_response (options_response);
+    return rc;
+  }
+  if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Refusing `%s' request to hostlist server\n"),
+                method);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop (
+                                "hostlist requests refused (not HTTP GET)"),
+                              1,
+                              GNUNET_YES);
+    return MHD_NO;
+  }
   if (NULL == *con_cls)
-    {
-      (*con_cls) = &dummy;
-      return MHD_YES;
-    }
+  {
+    (*con_cls) = &dummy;
+    return MHD_YES;
+  }
   if (0 != *upload_data_size)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Refusing `%s' request with %llu bytes of upload data\n"),
-                 method,
-                 (unsigned long long)*upload_data_size);
-      GNUNET_STATISTICS_update(stats,
-                               gettext_noop(
-                                 "hostlist requests refused (upload data)"),
-                               1,
-                               GNUNET_YES);
-      return MHD_NO; /* do not support upload data */
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Refusing `%s' request with %llu bytes of upload data\n"),
+                method,
+                (unsigned long long) *upload_data_size);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop (
+                                "hostlist requests refused (upload data)"),
+                              1,
+                              GNUNET_YES);
+    return MHD_NO;   /* do not support upload data */
+  }
   if (NULL == response)
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_WARNING,
-        _(
-          "Could not handle hostlist request since I do not have a response yet\n"));
-      GNUNET_STATISTICS_update(stats,
-                               gettext_noop(
-                                 "hostlist requests refused (not ready)"),
-                               1,
-                               GNUNET_YES);
-      return MHD_NO; /* internal error, no response yet */
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("Received request for our hostlist\n"));
-  GNUNET_STATISTICS_update(stats,
-                           gettext_noop("hostlist requests processed"),
-                           1,
-                           GNUNET_YES);
-  return MHD_queue_response(connection, MHD_HTTP_OK, response);
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_WARNING,
+      _ (
+        "Could not handle hostlist request since I do not have a response yet\n"));
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop (
+                                "hostlist requests refused (not ready)"),
+                              1,
+                              GNUNET_YES);
+    return MHD_NO;   /* internal error, no response yet */
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Received request for our hostlist\n"));
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("hostlist requests processed"),
+                            1,
+                            GNUNET_YES);
+  return MHD_queue_response (connection, MHD_HTTP_OK, response);
 }
 
 
@@ -432,33 +433,33 @@ access_handler_callback(void *cls,
  * @return number of bytes copied to @a buf
  */
 static void
-adv_transmit(struct GNUNET_MQ_Handle *mq)
+adv_transmit (struct GNUNET_MQ_Handle *mq)
 {
   static uint64_t hostlist_adv_count;
   size_t uri_size; /* Including \0 termination! */
   struct GNUNET_MessageHeader *header;
   struct GNUNET_MQ_Envelope *env;
 
-  uri_size = strlen(hostlist_uri) + 1;
-  env = GNUNET_MQ_msg_extra(header,
-                            uri_size,
-                            GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
-  GNUNET_memcpy(&header[1], hostlist_uri, uri_size);
-  GNUNET_MQ_env_set_options(env,
-                            GNUNET_MQ_PREF_CORK_ALLOWED |
-                            GNUNET_MQ_PREF_UNRELIABLE);
-  GNUNET_MQ_send(mq, env);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sent advertisement message: Copied %u bytes into buffer!\n",
-             (unsigned int)uri_size);
+  uri_size = strlen (hostlist_uri) + 1;
+  env = GNUNET_MQ_msg_extra (header,
+                             uri_size,
+                             GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
+  GNUNET_memcpy (&header[1], hostlist_uri, uri_size);
+  GNUNET_MQ_env_set_options (env,
+                             GNUNET_MQ_PREF_CORK_ALLOWED
+                             | GNUNET_MQ_PREF_UNRELIABLE);
+  GNUNET_MQ_send (mq, env);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sent advertisement message: Copied %u bytes into buffer!\n",
+              (unsigned int) uri_size);
   hostlist_adv_count++;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             " # Sent advertisement message: %llu\n",
-             (unsigned long long)hostlist_adv_count);
-  GNUNET_STATISTICS_update(stats,
-                           gettext_noop("# hostlist advertisements send"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              " # Sent advertisement message: %llu\n",
+              (unsigned long long) hostlist_adv_count);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# hostlist advertisements send"),
+                            1,
+                            GNUNET_NO);
 }
 
 
@@ -471,34 +472,34 @@ adv_transmit(struct GNUNET_MQ_Handle *mq)
  * @return NULL (must!)
  */
 static void *
-connect_handler(void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                struct GNUNET_MQ_Handle *mq)
+connect_handler (void *cls,
+                 const struct GNUNET_PeerIdentity *peer,
+                 struct GNUNET_MQ_Handle *mq)
 {
   size_t size;
 
-  if (!advertising)
+  if (! advertising)
     return NULL;
   if (NULL == hostlist_uri)
     return NULL;
-  size = strlen(hostlist_uri) + 1;
+  size = strlen (hostlist_uri) + 1;
   if (size + sizeof(struct GNUNET_MessageHeader) >= GNUNET_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   size += sizeof(struct GNUNET_MessageHeader);
   if (NULL == core)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  GNUNET_log(
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n",
-    (unsigned int)size,
-    GNUNET_i2s(peer));
-  adv_transmit(mq);
+    (unsigned int) size,
+    GNUNET_i2s (peer));
+  adv_transmit (mq);
   return NULL;
 }
 
@@ -513,36 +514,36 @@ connect_handler(void *cls,
  * @param err_msg NULL if successful, otherwise contains error message
  */
 static void
-process_notify(void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               const struct GNUNET_HELLO_Message *hello,
-               const char *err_msg)
+process_notify (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_HELLO_Message *hello,
+                const char *err_msg)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Peerinfo is notifying us to rebuild our hostlist\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peerinfo is notifying us to rebuild our hostlist\n");
   if (NULL != err_msg)
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               _("Error in communication with PEERINFO service: %s\n"),
-               err_msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Error in communication with PEERINFO service: %s\n"),
+                err_msg);
   if (NULL != builder)
+  {
+    /* restart re-build already in progress ... */
+    if (NULL != builder->pitr)
     {
-      /* restart re-build already in progress ... */
-      if (NULL != builder->pitr)
-        {
-          GNUNET_PEERINFO_iterate_cancel(builder->pitr);
-          builder->pitr = NULL;
-        }
-      GNUNET_free_non_null(builder->data);
-      builder->size = 0;
-      builder->data = NULL;
+      GNUNET_PEERINFO_iterate_cancel (builder->pitr);
+      builder->pitr = NULL;
     }
+    GNUNET_free_non_null (builder->data);
+    builder->size = 0;
+    builder->data = NULL;
+  }
   else
-    {
-      builder = GNUNET_new(struct HostSet);
-    }
-  GNUNET_assert(NULL != peerinfo);
+  {
+    builder = GNUNET_new (struct HostSet);
+  }
+  GNUNET_assert (NULL != peerinfo);
   builder->pitr =
-    GNUNET_PEERINFO_iterate(peerinfo, GNUNET_NO, NULL, &host_processor, NULL);
+    GNUNET_PEERINFO_iterate (peerinfo, GNUNET_NO, NULL, &host_processor, NULL);
 }
 
 
@@ -551,7 +552,7 @@ process_notify(void *cls,
  * starts the task waiting for them.
  */
 static struct GNUNET_SCHEDULER_Task *
-prepare_daemon(struct MHD_Daemon *daemon_handle);
+prepare_daemon (struct MHD_Daemon *daemon_handle);
 
 
 /**
@@ -561,7 +562,7 @@ prepare_daemon(struct MHD_Daemon *daemon_handle);
  * @param cls the `struct MHD_Daemon` of the HTTP server to run
  */
 static void
-run_daemon(void *cls)
+run_daemon (void *cls)
 {
   struct MHD_Daemon *daemon_handle = cls;
 
@@ -569,11 +570,11 @@ run_daemon(void *cls)
     hostlist_task_v4 = NULL;
   else
     hostlist_task_v6 = NULL;
-  GNUNET_assert(MHD_YES == MHD_run(daemon_handle));
+  GNUNET_assert (MHD_YES == MHD_run (daemon_handle));
   if (daemon_handle == daemon_handle_v4)
-    hostlist_task_v4 = prepare_daemon(daemon_handle);
+    hostlist_task_v4 = prepare_daemon (daemon_handle);
   else
-    hostlist_task_v6 = prepare_daemon(daemon_handle);
+    hostlist_task_v6 = prepare_daemon (daemon_handle);
 }
 
 
@@ -584,7 +585,7 @@ run_daemon(void *cls)
  * @param daemon_handle HTTP server to prepare to run
  */
 static struct GNUNET_SCHEDULER_Task *
-prepare_daemon(struct MHD_Daemon *daemon_handle)
+prepare_daemon (struct MHD_Daemon *daemon_handle)
 {
   struct GNUNET_SCHEDULER_Task *ret;
   fd_set rs;
@@ -597,28 +598,28 @@ prepare_daemon(struct MHD_Daemon *daemon_handle)
   int haveto;
   struct GNUNET_TIME_Relative tv;
 
-  FD_ZERO(&rs);
-  FD_ZERO(&ws);
-  FD_ZERO(&es);
-  wrs = GNUNET_NETWORK_fdset_create();
-  wws = GNUNET_NETWORK_fdset_create();
+  FD_ZERO (&rs);
+  FD_ZERO (&ws);
+  FD_ZERO (&es);
+  wrs = GNUNET_NETWORK_fdset_create ();
+  wws = GNUNET_NETWORK_fdset_create ();
   max = -1;
-  GNUNET_assert(MHD_YES == MHD_get_fdset(daemon_handle, &rs, &ws, &es, &max));
-  haveto = MHD_get_timeout(daemon_handle, &timeout);
+  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_us = (uint64_t)timeout * 1000LL;
+    tv.rel_value_us = (uint64_t) timeout * 1000LL;
   else
     tv = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_NETWORK_fdset_copy_native(wrs, &rs, max + 1);
-  GNUNET_NETWORK_fdset_copy_native(wws, &ws, max + 1);
-  ret = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                    tv,
-                                    wrs,
-                                    wws,
-                                    &run_daemon,
-                                    daemon_handle);
-  GNUNET_NETWORK_fdset_destroy(wrs);
-  GNUNET_NETWORK_fdset_destroy(wws);
+  GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
+  GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
+  ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                     tv,
+                                     wrs,
+                                     wws,
+                                     &run_daemon,
+                                     daemon_handle);
+  GNUNET_NETWORK_fdset_destroy (wrs);
+  GNUNET_NETWORK_fdset_destroy (wws);
   return ret;
 }
 
@@ -634,11 +635,11 @@ prepare_daemon(struct MHD_Daemon *daemon_handle)
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c,
-                             struct GNUNET_STATISTICS_Handle *st,
-                             struct GNUNET_CORE_Handle *co,
-                             GNUNET_CORE_ConnectEventHandler *server_ch,
-                             int advertise)
+GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
+                              struct GNUNET_STATISTICS_Handle *st,
+                              struct GNUNET_CORE_Handle *co,
+                              GNUNET_CORE_ConnectEventHandler *server_ch,
+                              int advertise)
 {
   unsigned long long port;
   char *hostname;
@@ -653,189 +654,189 @@ GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c,
   const struct sockaddr *sa6;
 
   advertising = advertise;
-  if (!advertising)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Advertising not enabled on this hostlist server\n");
-    }
+  if (! advertising)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Advertising not enabled on this hostlist server\n");
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Advertising enabled on this hostlist server\n");
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Advertising enabled on this hostlist server\n");
+  }
   cfg = c;
   stats = st;
-  peerinfo = GNUNET_PEERINFO_connect(cfg);
+  peerinfo = GNUNET_PEERINFO_connect (cfg);
   if (NULL == peerinfo)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Could not access PEERINFO service.  Exiting.\n"));
-      return GNUNET_SYSERR;
-    }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                         "HOSTLIST",
-                                                         "HTTPPORT",
-                                                         &port))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not access PEERINFO service.  Exiting.\n"));
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                          "HOSTLIST",
+                                                          "HTTPPORT",
+                                                          &port))
     return GNUNET_SYSERR;
   if ((0 == port) || (port > UINT16_MAX))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Invalid port number %llu.  Exiting.\n"),
-                 port);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Invalid port number %llu.  Exiting.\n"),
+                port);
+    return GNUNET_SYSERR;
+  }
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string(cfg,
-                                            "HOSTLIST",
-                                            "EXTERNAL_DNS_NAME",
-                                            &hostname))
-    hostname = GNUNET_RESOLVER_local_fqdn_get();
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("Hostlist service starts on %s:%llu\n"),
-             hostname,
-             port);
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "HOSTLIST",
+                                             "EXTERNAL_DNS_NAME",
+                                             &hostname))
+    hostname = GNUNET_RESOLVER_local_fqdn_get ();
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Hostlist service starts on %s:%llu\n"),
+              hostname,
+              port);
   if (NULL != hostname)
+  {
+    size = strlen (hostname);
+    if (size + 15 > MAX_URL_LEN)
     {
-      size = strlen(hostname);
-      if (size + 15 > MAX_URL_LEN)
-        {
-          GNUNET_break(0);
-        }
-      else
-        {
-          GNUNET_asprintf(&hostlist_uri,
-                          "http://%s:%u/",
-                          hostname,
-                          (unsigned int)port);
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     _("Address to obtain hostlist: `%s'\n"),
-                     hostlist_uri);
-        }
-      GNUNET_free(hostname);
+      GNUNET_break (0);
     }
+    else
+    {
+      GNUNET_asprintf (&hostlist_uri,
+                       "http://%s:%u/",
+                       hostname,
+                       (unsigned int) port);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Address to obtain hostlist: `%s'\n"),
+                  hostlist_uri);
+    }
+    GNUNET_free (hostname);
+  }
 
-  if (GNUNET_CONFIGURATION_have_value(cfg, "HOSTLIST", "BINDTOIPV4"))
+  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4"))
+  {
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                            "HOSTLIST",
+                                                            "BINDTOIP",
+                                                            &ipv4))
     {
-      if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             "HOSTLIST",
-                                                             "BINDTOIP",
-                                                             &ipv4))
-        {
-          GNUNET_log(
-            GNUNET_ERROR_TYPE_WARNING,
-            _("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
-        }
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_WARNING,
+        _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
     }
+  }
   else
     ipv4 = NULL;
-  if (GNUNET_CONFIGURATION_have_value(cfg, "HOSTLIST", "BINDTOIPV6"))
-    {
-      if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             "HOSTLIST",
-                                                             "BINDTOIP",
-                                                             &ipv6))
-        {
-          GNUNET_log(
-            GNUNET_ERROR_TYPE_WARNING,
-            _("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
-        }
+  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6"))
+  {
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                            "HOSTLIST",
+                                                            "BINDTOIP",
+                                                            &ipv6))
+    {
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_WARNING,
+        _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
     }
+  }
   else
     ipv6 = NULL;
   sa4 = NULL;
   if (NULL != ipv4)
+  {
+    if (1 == inet_pton (AF_INET, ipv4, &i4))
     {
-      if (1 == inet_pton(AF_INET, ipv4, &i4))
-        {
-          memset(&v4, 0, sizeof(v4));
-          v4.sin_family = AF_INET;
-          v4.sin_addr = i4;
-          v4.sin_port = htons(port);
+      memset (&v4, 0, sizeof(v4));
+      v4.sin_family = AF_INET;
+      v4.sin_addr = i4;
+      v4.sin_port = htons (port);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          v4.sin_len = sizeof(v4);
+      v4.sin_len = sizeof(v4);
 #endif
-          sa4 = (const struct sockaddr *)&v4;
-        }
-      else
-        GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                   _(
-                     "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"),
-                   ipv4);
-      GNUNET_free(ipv4);
-    }
+      sa4 = (const struct sockaddr *) &v4;
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _ (
+                    "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"),
+                  ipv4);
+    GNUNET_free (ipv4);
+  }
   sa6 = NULL;
   if (NULL != ipv6)
+  {
+    if (1 == inet_pton (AF_INET6, ipv6, &i6))
     {
-      if (1 == inet_pton(AF_INET6, ipv6, &i6))
-        {
-          memset(&v6, 0, sizeof(v6));
-          v6.sin6_family = AF_INET6;
-          v6.sin6_addr = i6;
-          v6.sin6_port = htons(port);
+      memset (&v6, 0, sizeof(v6));
+      v6.sin6_family = AF_INET6;
+      v6.sin6_addr = i6;
+      v6.sin6_port = htons (port);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          v6.sin6_len = sizeof(v6);
+      v6.sin6_len = sizeof(v6);
 #endif
-          sa6 = (const struct sockaddr *)&v6;
-        }
-      else
-        GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                   _(
-                     "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"),
-                   ipv6);
-      GNUNET_free(ipv6);
-    }
-
-  daemon_handle_v6 = MHD_start_daemon(MHD_USE_IPv6 | MHD_USE_DEBUG,
-                                      (uint16_t)port,
-                                      &accept_policy_callback,
-                                      NULL,
-                                      &access_handler_callback,
-                                      NULL,
-                                      MHD_OPTION_CONNECTION_LIMIT,
-                                      (unsigned int)128,
-                                      MHD_OPTION_PER_IP_CONNECTION_LIMIT,
-                                      (unsigned int)32,
-                                      MHD_OPTION_CONNECTION_TIMEOUT,
-                                      (unsigned int)16,
-                                      MHD_OPTION_CONNECTION_MEMORY_LIMIT,
-                                      (size_t)(16 * 1024),
-                                      MHD_OPTION_SOCK_ADDR,
-                                      sa6,
-                                      MHD_OPTION_END);
-  daemon_handle_v4 = MHD_start_daemon(MHD_NO_FLAG | MHD_USE_DEBUG,
-                                      (uint16_t)port,
-                                      &accept_policy_callback,
-                                      NULL,
-                                      &access_handler_callback,
-                                      NULL,
-                                      MHD_OPTION_CONNECTION_LIMIT,
-                                      (unsigned int)128,
-                                      MHD_OPTION_PER_IP_CONNECTION_LIMIT,
-                                      (unsigned int)32,
-                                      MHD_OPTION_CONNECTION_TIMEOUT,
-                                      (unsigned int)16,
-                                      MHD_OPTION_CONNECTION_MEMORY_LIMIT,
-                                      (size_t)(16 * 1024),
-                                      MHD_OPTION_SOCK_ADDR,
-                                      sa4,
-                                      MHD_OPTION_END);
+      sa6 = (const struct sockaddr *) &v6;
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _ (
+                    "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"),
+                  ipv6);
+    GNUNET_free (ipv6);
+  }
+
+  daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG,
+                                       (uint16_t) port,
+                                       &accept_policy_callback,
+                                       NULL,
+                                       &access_handler_callback,
+                                       NULL,
+                                       MHD_OPTION_CONNECTION_LIMIT,
+                                       (unsigned int) 128,
+                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
+                                       (unsigned int) 32,
+                                       MHD_OPTION_CONNECTION_TIMEOUT,
+                                       (unsigned int) 16,
+                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                                       (size_t) (16 * 1024),
+                                       MHD_OPTION_SOCK_ADDR,
+                                       sa6,
+                                       MHD_OPTION_END);
+  daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG,
+                                       (uint16_t) port,
+                                       &accept_policy_callback,
+                                       NULL,
+                                       &access_handler_callback,
+                                       NULL,
+                                       MHD_OPTION_CONNECTION_LIMIT,
+                                       (unsigned int) 128,
+                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
+                                       (unsigned int) 32,
+                                       MHD_OPTION_CONNECTION_TIMEOUT,
+                                       (unsigned int) 16,
+                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                                       (size_t) (16 * 1024),
+                                       MHD_OPTION_SOCK_ADDR,
+                                       sa4,
+                                       MHD_OPTION_END);
 
   if ((NULL == daemon_handle_v6) && (NULL == daemon_handle_v4))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Could not start hostlist HTTP server on port %u\n"),
-                 (unsigned short)port);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not start hostlist HTTP server on port %u\n"),
+                (unsigned short) port);
+    return GNUNET_SYSERR;
+  }
 
   core = co;
   *server_ch = &connect_handler;
   if (NULL != daemon_handle_v4)
-    hostlist_task_v4 = prepare_daemon(daemon_handle_v4);
+    hostlist_task_v4 = prepare_daemon (daemon_handle_v4);
   if (NULL != daemon_handle_v6)
-    hostlist_task_v6 = prepare_daemon(daemon_handle_v6);
-  notify = GNUNET_PEERINFO_notify(cfg, GNUNET_NO, &process_notify, NULL);
+    hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
+  notify = GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_notify, NULL);
   return GNUNET_OK;
 }
 
@@ -844,55 +845,55 @@ GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c,
  * Stop server offering our hostlist.
  */
 void
-GNUNET_HOSTLIST_server_stop()
+GNUNET_HOSTLIST_server_stop ()
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
   if (NULL != hostlist_task_v6)
-    {
-      GNUNET_SCHEDULER_cancel(hostlist_task_v6);
-      hostlist_task_v6 = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (hostlist_task_v6);
+    hostlist_task_v6 = NULL;
+  }
   if (NULL != hostlist_task_v4)
-    {
-      GNUNET_SCHEDULER_cancel(hostlist_task_v4);
-      hostlist_task_v4 = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (hostlist_task_v4);
+    hostlist_task_v4 = NULL;
+  }
   if (NULL != daemon_handle_v4)
-    {
-      MHD_stop_daemon(daemon_handle_v4);
-      daemon_handle_v4 = NULL;
-    }
+  {
+    MHD_stop_daemon (daemon_handle_v4);
+    daemon_handle_v4 = NULL;
+  }
   if (NULL != daemon_handle_v6)
-    {
-      MHD_stop_daemon(daemon_handle_v6);
-      daemon_handle_v6 = NULL;
-    }
+  {
+    MHD_stop_daemon (daemon_handle_v6);
+    daemon_handle_v6 = NULL;
+  }
   if (NULL != response)
-    {
-      MHD_destroy_response(response);
-      response = NULL;
-    }
+  {
+    MHD_destroy_response (response);
+    response = NULL;
+  }
   if (NULL != notify)
-    {
-      GNUNET_PEERINFO_notify_cancel(notify);
-      notify = NULL;
-    }
+  {
+    GNUNET_PEERINFO_notify_cancel (notify);
+    notify = NULL;
+  }
   if (NULL != builder)
+  {
+    if (NULL != builder->pitr)
     {
-      if (NULL != builder->pitr)
-        {
-          GNUNET_PEERINFO_iterate_cancel(builder->pitr);
-          builder->pitr = NULL;
-        }
-      GNUNET_free_non_null(builder->data);
-      GNUNET_free(builder);
-      builder = NULL;
+      GNUNET_PEERINFO_iterate_cancel (builder->pitr);
+      builder->pitr = NULL;
     }
+    GNUNET_free_non_null (builder->data);
+    GNUNET_free (builder);
+    builder = NULL;
+  }
   if (NULL != peerinfo)
-    {
-      GNUNET_PEERINFO_disconnect(peerinfo);
-      peerinfo = NULL;
-    }
+  {
+    GNUNET_PEERINFO_disconnect (peerinfo);
+    peerinfo = NULL;
+  }
   cfg = NULL;
   stats = NULL;
   core = NULL;
diff --git a/src/hostlist/gnunet-daemon-hostlist_server.h b/src/hostlist/gnunet-daemon-hostlist_server.h
index 407675b41..13ba21e82 100644
--- a/src/hostlist/gnunet-daemon-hostlist_server.h
+++ b/src/hostlist/gnunet-daemon-hostlist_server.h
@@ -43,18 +43,18 @@
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c,
-                             struct GNUNET_STATISTICS_Handle *st,
-                             struct GNUNET_CORE_Handle *core,
-                             GNUNET_CORE_ConnectEventHandler *server_ch,
-                             int advertise);
+GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
+                              struct GNUNET_STATISTICS_Handle *st,
+                              struct GNUNET_CORE_Handle *core,
+                              GNUNET_CORE_ConnectEventHandler *server_ch,
+                              int advertise);
 
 
 /**
  * Stop server offering our hostlist.
  */
 void
-GNUNET_HOSTLIST_server_stop(void);
+GNUNET_HOSTLIST_server_stop (void);
 
 
 #endif
diff --git a/src/hostlist/test_gnunet_daemon_hostlist.c b/src/hostlist/test_gnunet_daemon_hostlist.c
index d6853c184..182340f9b 100644
--- a/src/hostlist/test_gnunet_daemon_hostlist.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist.c
@@ -32,13 +32,14 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 150)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 150)
 
 static int ok;
 
 static struct GNUNET_SCHEDULER_Task *timeout_task;
 
-struct PeerContext {
+struct PeerContext
+{
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_TRANSPORT_CoreHandle *th;
   struct GNUNET_MessageHeader *hello;
@@ -52,29 +53,29 @@ static struct PeerContext p2;
 
 
 static void
-clean_up(void *cls)
+clean_up (void *cls)
 {
   if (NULL != p1.th)
+  {
+    if (NULL != p1.ghh)
     {
-      if (NULL != p1.ghh)
-        {
-          GNUNET_TRANSPORT_hello_get_cancel(p1.ghh);
-          p1.ghh = NULL;
-        }
-      GNUNET_TRANSPORT_core_disconnect(p1.th);
-      p1.th = NULL;
+      GNUNET_TRANSPORT_hello_get_cancel (p1.ghh);
+      p1.ghh = NULL;
     }
+    GNUNET_TRANSPORT_core_disconnect (p1.th);
+    p1.th = NULL;
+  }
   if (NULL != p2.th)
+  {
+    if (NULL != p2.ghh)
     {
-      if (NULL != p2.ghh)
-        {
-          GNUNET_TRANSPORT_hello_get_cancel(p2.ghh);
-          p2.ghh = NULL;
-        }
-      GNUNET_TRANSPORT_core_disconnect(p2.th);
-      p2.th = NULL;
+      GNUNET_TRANSPORT_hello_get_cancel (p2.ghh);
+      p2.ghh = NULL;
     }
-  GNUNET_SCHEDULER_shutdown();
+    GNUNET_TRANSPORT_core_disconnect (p2.th);
+    p2.th = NULL;
+  }
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -82,12 +83,12 @@ clean_up(void *cls)
  * Timeout, give up.
  */
 static void
-timeout_error(void *cls)
+timeout_error (void *cls)
 {
   timeout_task = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Timeout trying to connect peers, test failed.\n");
-  clean_up(NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout trying to connect peers, test failed.\n");
+  clean_up (NULL);
 }
 
 
@@ -100,92 +101,92 @@ timeout_error(void *cls)
  * @param mq message queue to send messages to the peer
  */
 static void *
-notify_connect(void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               struct GNUNET_MQ_Handle *mq)
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n");
   ok = 0;
   if (NULL != timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
-  GNUNET_SCHEDULER_add_now(&clean_up, NULL);
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
+  GNUNET_SCHEDULER_add_now (&clean_up, NULL);
   return NULL;
 }
 
 
 static void
-process_hello(void *cls, const struct GNUNET_MessageHeader *message)
+process_hello (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *p = cls;
 
-  GNUNET_TRANSPORT_hello_get_cancel(p->ghh);
+  GNUNET_TRANSPORT_hello_get_cancel (p->ghh);
   p->ghh = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received HELLO, starting hostlist service.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received HELLO, starting hostlist service.\n");
 }
 
 
 static void
-setup_peer(struct PeerContext *p, const char *cfgname)
+setup_peer (struct PeerContext *p, const char *cfgname)
 {
   char *binary;
 
-  binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm");
-  p->cfg = GNUNET_CONFIGURATION_create();
-  p->arm_proc = GNUNET_OS_start_process(GNUNET_YES,
-                                        GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                        NULL,
-                                        NULL,
-                                        NULL,
-                                        binary,
-                                        "gnunet-service-arm",
-                                        "-c",
-                                        cfgname,
-                                        NULL);
-  GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_load(p->cfg, cfgname));
-  p->th = GNUNET_TRANSPORT_core_connect(p->cfg,
-                                        NULL,
-                                        NULL,
-                                        p,
-                                        &notify_connect,
-                                        NULL,
-                                        NULL);
-  GNUNET_assert(NULL != p->th);
-  p->ghh = GNUNET_TRANSPORT_hello_get(p->cfg,
-                                      GNUNET_TRANSPORT_AC_ANY,
-                                      &process_hello,
-                                      p);
-  GNUNET_free(binary);
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
+  p->cfg = GNUNET_CONFIGURATION_create ();
+  p->arm_proc = GNUNET_OS_start_process (GNUNET_YES,
+                                         GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                         NULL,
+                                         NULL,
+                                         NULL,
+                                         binary,
+                                         "gnunet-service-arm",
+                                         "-c",
+                                         cfgname,
+                                         NULL);
+  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
+                                         NULL,
+                                         NULL,
+                                         p,
+                                         &notify_connect,
+                                         NULL,
+                                         NULL);
+  GNUNET_assert (NULL != p->th);
+  p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
+                                       GNUNET_TRANSPORT_AC_ANY,
+                                       &process_hello,
+                                       p);
+  GNUNET_free (binary);
 }
 
 
 static void
-waitpid_task(void *cls)
+waitpid_task (void *cls)
 {
   struct PeerContext *p = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n");
-  if (0 != GNUNET_OS_process_kill(p->arm_proc, GNUNET_TERM_SIG))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
-  if (GNUNET_OK != GNUNET_OS_process_wait(p->arm_proc))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "waitpid");
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "ARM process %u stopped\n",
-             GNUNET_OS_process_get_pid(p->arm_proc));
-  GNUNET_OS_process_destroy(p->arm_proc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n");
+  if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OK != GNUNET_OS_process_wait (p->arm_proc))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ARM process %u stopped\n",
+              GNUNET_OS_process_get_pid (p->arm_proc));
+  GNUNET_OS_process_destroy (p->arm_proc);
   p->arm_proc = NULL;
-  GNUNET_CONFIGURATION_destroy(p->cfg);
+  GNUNET_CONFIGURATION_destroy (p->cfg);
 }
 
 
 static void
-stop_arm(struct PeerContext *p)
+stop_arm (struct PeerContext *p)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n");
-  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n");
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p);
 }
 
 
@@ -193,68 +194,69 @@ stop_arm(struct PeerContext *p)
  * Try again to connect to transport service.
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
-  stop_arm(&p1);
-  stop_arm(&p2);
+  stop_arm (&p1);
+  stop_arm (&p2);
 }
 
 
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  GNUNET_assert(ok == 1);
+  GNUNET_assert (ok == 1);
   ok++;
-  timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_error, NULL);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
-  setup_peer(&p1, "test_gnunet_daemon_hostlist_peer1.conf");
-  setup_peer(&p2, "test_gnunet_daemon_hostlist_peer2.conf");
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  setup_peer (&p1, "test_gnunet_daemon_hostlist_peer1.conf");
+  setup_peer (&p2, "test_gnunet_daemon_hostlist_peer2.conf");
 }
 
 
 static int
-check()
+check ()
 {
   char *const argv[] = { "test-gnunet-daemon-hostlist",
                          "-c",
                          "test_gnunet_daemon_hostlist_data.conf",
                          NULL };
-  struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_OPTION_END };
+  struct GNUNET_GETOPT_CommandLineOption options[] =
+  { GNUNET_GETOPT_OPTION_END };
 
   ok = 1;
-  GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1,
-                     argv,
-                     "test-gnunet-daemon-hostlist",
-                     "nohelp",
-                     options,
-                     &run,
-                     &ok);
+  GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1,
+                      argv,
+                      "test-gnunet-daemon-hostlist",
+                      "nohelp",
+                      options,
+                      &run,
+                      &ok);
   return ok;
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   int ret;
 
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_log_setup("test-gnunet-daemon-hostlist", "WARNING", NULL);
-  ret = check();
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf",
-                            "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_log_setup ("test-gnunet-daemon-hostlist", "WARNING", NULL);
+  ret = check ();
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf",
+                             "GNUNET_TEST_HOME");
   return ret;
 }
 
diff --git a/src/hostlist/test_gnunet_daemon_hostlist_learning.c b/src/hostlist/test_gnunet_daemon_hostlist_learning.c
index fa72ac828..f9fabab10 100644
--- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.c
@@ -35,12 +35,14 @@
 /**
  * How long until wait until testcases fails
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 180)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180)
 
-#define CHECK_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1)
+#define CHECK_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \
+                                                      1)
 
 
-struct PeerContext {
+struct PeerContext
+{
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_MessageHeader *hello;
   struct GNUNET_CORE_Handle *core;
@@ -78,86 +80,86 @@ static struct GNUNET_STATISTICS_GetHandle *advsent_stat;
 
 
 static void
-shutdown_testcase()
+shutdown_testcase ()
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Shutdown testcase....\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown testcase....\n");
   if (NULL != timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
   if (NULL != download_stats)
-    {
-      GNUNET_STATISTICS_get_cancel(download_stats);
-      download_stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (download_stats);
+    download_stats = NULL;
+  }
   if (NULL != urisrecv_stat)
-    {
-      GNUNET_STATISTICS_get_cancel(urisrecv_stat);
-      urisrecv_stat = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (urisrecv_stat);
+    urisrecv_stat = NULL;
+  }
   if (NULL != advsent_stat)
-    {
-      GNUNET_STATISTICS_get_cancel(advsent_stat);
-      advsent_stat = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (advsent_stat);
+    advsent_stat = NULL;
+  }
   if (NULL != adv_peer.stats)
-    {
-      GNUNET_STATISTICS_destroy(adv_peer.stats, GNUNET_NO);
-      adv_peer.stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (adv_peer.stats, GNUNET_NO);
+    adv_peer.stats = NULL;
+  }
   if (NULL != learn_peer.stats)
-    {
-      GNUNET_STATISTICS_destroy(learn_peer.stats, GNUNET_NO);
-      learn_peer.stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (learn_peer.stats, GNUNET_NO);
+    learn_peer.stats = NULL;
+  }
   if (NULL != check_task)
-    {
-      GNUNET_SCHEDULER_cancel(check_task);
-      check_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (check_task);
+    check_task = NULL;
+  }
   if (NULL != current_adv_uri)
-    {
-      GNUNET_free(current_adv_uri);
-      current_adv_uri = NULL;
-    }
+  {
+    GNUNET_free (current_adv_uri);
+    current_adv_uri = NULL;
+  }
   if (NULL != adv_peer.core)
-    {
-      GNUNET_CORE_disconnect(adv_peer.core);
-      adv_peer.core = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (adv_peer.core);
+    adv_peer.core = NULL;
+  }
   if (NULL != learn_peer.core)
-    {
-      GNUNET_CORE_disconnect(learn_peer.core);
-      learn_peer.core = NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Killing hostlist server ARM process.\n");
-  if (0 != GNUNET_OS_process_kill(adv_peer.arm_proc,
-                                  GNUNET_TERM_SIG))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
-                        "kill");
+  {
+    GNUNET_CORE_disconnect (learn_peer.core);
+    learn_peer.core = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Killing hostlist server ARM process.\n");
+  if (0 != GNUNET_OS_process_kill (adv_peer.arm_proc,
+                                   GNUNET_TERM_SIG))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                         "kill");
   if (GNUNET_OK !=
-      GNUNET_OS_process_wait(adv_peer.arm_proc))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
-                        "waitpid");
-  GNUNET_OS_process_destroy(adv_peer.arm_proc);
+      GNUNET_OS_process_wait (adv_peer.arm_proc))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                         "waitpid");
+  GNUNET_OS_process_destroy (adv_peer.arm_proc);
   adv_peer.arm_proc = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Killing hostlist client ARM process.\n");
-  if (0 != GNUNET_OS_process_kill(learn_peer.arm_proc,
-                                  GNUNET_TERM_SIG))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
-                        "kill");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Killing hostlist client ARM process.\n");
+  if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc,
+                                   GNUNET_TERM_SIG))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                         "kill");
   if (GNUNET_OK !=
-      GNUNET_OS_process_wait(learn_peer.arm_proc))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
-                        "waitpid");
-  GNUNET_OS_process_destroy(learn_peer.arm_proc);
+      GNUNET_OS_process_wait (learn_peer.arm_proc))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                         "waitpid");
+  GNUNET_OS_process_destroy (learn_peer.arm_proc);
   learn_peer.arm_proc = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Shutdown complete....\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown complete....\n");
 }
 
 
@@ -165,112 +167,112 @@ shutdown_testcase()
  * Timeout, give up.
  */
 static void
-timeout_error(void *cls)
+timeout_error (void *cls)
 {
   timeout_task = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Timeout while executing testcase, test failed.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout while executing testcase, test failed.\n");
   timeout = GNUNET_YES;
-  shutdown_testcase();
+  shutdown_testcase ();
 }
 
 
 static void
-process_downloads_done(void *cls, int success)
+process_downloads_done (void *cls, int success)
 {
   download_stats = NULL;
 }
 
 
 static void
-do_shutdown(void *cls)
+do_shutdown (void *cls)
 {
-  shutdown_testcase();
+  shutdown_testcase ();
 }
 
 
 static int
-process_downloads(void *cls,
-                  const char *subsystem,
-                  const char *name,
-                  uint64_t value,
-                  int is_persistent)
+process_downloads (void *cls,
+                   const char *subsystem,
+                   const char *name,
+                   uint64_t value,
+                   int is_persistent)
 {
   if ((value >= 2) &&
       (GNUNET_NO == learned_hostlist_downloaded))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peer has successfully downloaded advertised URI\n");
+    learned_hostlist_downloaded = GNUNET_YES;
+    if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Peer has successfully downloaded advertised URI\n");
-      learned_hostlist_downloaded = GNUNET_YES;
-      if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES))
-        {
-          GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-        }
+      GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
     }
+  }
   return GNUNET_OK;
 }
 
 
 static void
-process_uris_recv_done(void *cls, int success)
+process_uris_recv_done (void *cls, int success)
 {
   urisrecv_stat = NULL;
 }
 
 
 static int
-process_uris_recv(void *cls,
-                  const char *subsystem,
-                  const char *name,
-                  uint64_t value,
-                  int is_persistent)
+process_uris_recv (void *cls,
+                   const char *subsystem,
+                   const char *name,
+                   uint64_t value,
+                   int is_persistent)
 {
   struct PeerContext *pc = cls;
 
   if ((pc == &learn_peer) &&
       (value == 1) &&
       (learned_hostlist_saved == GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peer has successfully saved advertised URI\n");
+    learned_hostlist_saved = GNUNET_YES;
+    if ((learned_hostlist_downloaded == GNUNET_YES) &&
+        (adv_sent == GNUNET_YES))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Peer has successfully saved advertised URI\n");
-      learned_hostlist_saved = GNUNET_YES;
-      if ((learned_hostlist_downloaded == GNUNET_YES) &&
-          (adv_sent == GNUNET_YES))
-        {
-          GNUNET_SCHEDULER_add_now(&do_shutdown,
-                                   NULL);
-        }
+      GNUNET_SCHEDULER_add_now (&do_shutdown,
+                                NULL);
     }
+  }
   return GNUNET_OK;
 }
 
 
 static void
-process_adv_sent_done(void *cls, int success)
+process_adv_sent_done (void *cls, int success)
 {
   advsent_stat = NULL;
 }
 
 
 static int
-process_adv_sent(void *cls,
-                 const char *subsystem,
-                 const char *name,
-                 uint64_t value,
-                 int is_persistent)
+process_adv_sent (void *cls,
+                  const char *subsystem,
+                  const char *name,
+                  uint64_t value,
+                  int is_persistent)
 {
   if ((value >= 1) && (adv_sent == GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Server has successfully sent advertisement\n");
+    adv_sent = GNUNET_YES;
+    if ((learned_hostlist_downloaded == GNUNET_YES) &&
+        (learned_hostlist_saved == GNUNET_YES))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Server has successfully sent advertisement\n");
-      adv_sent = GNUNET_YES;
-      if ((learned_hostlist_downloaded == GNUNET_YES) &&
-          (learned_hostlist_saved == GNUNET_YES))
-        {
-          GNUNET_SCHEDULER_add_now(&do_shutdown,
-                                   NULL);
-        }
+      GNUNET_SCHEDULER_add_now (&do_shutdown,
+                                NULL);
     }
+  }
   return GNUNET_OK;
 }
 
@@ -279,70 +281,71 @@ process_adv_sent(void *cls,
  * Check the server statistics regularly
  */
 static void
-check_statistics(void *cls)
+check_statistics (void *cls)
 {
   char *stat;
 
   check_task = NULL;
-  GNUNET_asprintf(&stat,
-                  gettext_noop("# advertised URI `%s' downloaded"),
-                  current_adv_uri);
+  GNUNET_asprintf (&stat,
+                   gettext_noop ("# advertised URI `%s' downloaded"),
+                   current_adv_uri);
   if (NULL != learn_peer.stats)
-    {
-      if (NULL != download_stats)
-        GNUNET_STATISTICS_get_cancel(download_stats);
-      download_stats =
-        GNUNET_STATISTICS_get(learn_peer.stats,
-                              "hostlist",
-                              stat,
-                              &process_downloads_done,
-                              &process_downloads,
-                              &learn_peer);
-      if (NULL != urisrecv_stat)
-        GNUNET_STATISTICS_get_cancel(urisrecv_stat);
-      urisrecv_stat =
-        GNUNET_STATISTICS_get(learn_peer.stats, "hostlist",
-                              gettext_noop("# advertised hostlist URIs"),
-                              &process_uris_recv_done, &process_uris_recv,
-                              &learn_peer);
-    }
-  GNUNET_free(stat);
+  {
+    if (NULL != download_stats)
+      GNUNET_STATISTICS_get_cancel (download_stats);
+    download_stats =
+      GNUNET_STATISTICS_get (learn_peer.stats,
+                             "hostlist",
+                             stat,
+                             &process_downloads_done,
+                             &process_downloads,
+                             &learn_peer);
+    if (NULL != urisrecv_stat)
+      GNUNET_STATISTICS_get_cancel (urisrecv_stat);
+    urisrecv_stat =
+      GNUNET_STATISTICS_get (learn_peer.stats, "hostlist",
+                             gettext_noop ("# advertised hostlist URIs"),
+                             &process_uris_recv_done, &process_uris_recv,
+                             &learn_peer);
+  }
+  GNUNET_free (stat);
   if (NULL != adv_peer.stats)
-    {
-      if (NULL != advsent_stat)
-        GNUNET_STATISTICS_get_cancel(advsent_stat);
-      advsent_stat =
-        GNUNET_STATISTICS_get(adv_peer.stats, "hostlist",
-                              gettext_noop("# hostlist advertisements send"),
-                              &process_adv_sent_done,
-                              &process_adv_sent,
-                              NULL);
-    }
+  {
+    if (NULL != advsent_stat)
+      GNUNET_STATISTICS_get_cancel (advsent_stat);
+    advsent_stat =
+      GNUNET_STATISTICS_get (adv_peer.stats, "hostlist",
+                             gettext_noop ("# hostlist advertisements send"),
+                             &process_adv_sent_done,
+                             &process_adv_sent,
+                             NULL);
+  }
   check_task =
-    GNUNET_SCHEDULER_add_delayed(CHECK_INTERVAL,
-                                 &check_statistics,
-                                 NULL);
+    GNUNET_SCHEDULER_add_delayed (CHECK_INTERVAL,
+                                  &check_statistics,
+                                  NULL);
 }
 
 
 static int
-check_ad_arrive(void *cls,
-                const struct GNUNET_MessageHeader *message)
+check_ad_arrive (void *cls,
+                 const struct GNUNET_MessageHeader *message)
 {
-  const char *end = (const char *)&message[1];
-
-  if ('\0' != end[ntohs(message->size) - sizeof(struct GNUNET_MessageHeader) - 1])
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  const char *end = (const char *) &message[1];
+
+  if ('\0' != end[ntohs (message->size) - sizeof(struct GNUNET_MessageHeader)
+                  - 1])
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
 
 static void
-handle_ad_arrive(void *cls,
-                 const struct GNUNET_MessageHeader *message)
+handle_ad_arrive (void *cls,
+                  const struct GNUNET_MessageHeader *message)
 {
   char *hostname;
   char *expected_uri;
@@ -350,132 +353,132 @@ handle_ad_arrive(void *cls,
   const char *end;
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_number(adv_peer.cfg,
-                                            "HOSTLIST",
-                                            "HTTPPORT",
-                                            &port))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Could not read advertising server's configuration\n");
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg,
+                                             "HOSTLIST",
+                                             "HTTPPORT",
+                                             &port))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not read advertising server's configuration\n");
+    return;
+  }
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string(adv_peer.cfg,
-                                            "HOSTLIST",
-                                            "EXTERNAL_DNS_NAME",
-                                            &hostname))
-    hostname = GNUNET_RESOLVER_local_fqdn_get();
-  GNUNET_asprintf(&expected_uri,
-                  "http://%s:%u/",
-                  hostname != NULL ? hostname : "localhost",
-                  (unsigned int)port);
-  end = (const char *)&message[1];
-  current_adv_uri = GNUNET_strdup(end);
-  if (0 == strcmp(expected_uri,
-                  current_adv_uri))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Received hostlist advertisement with URI `%s' as expected\n",
-                 current_adv_uri);
-      adv_arrived = GNUNET_YES;
-      adv_sent = GNUNET_YES;
-    }
+      GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg,
+                                             "HOSTLIST",
+                                             "EXTERNAL_DNS_NAME",
+                                             &hostname))
+    hostname = GNUNET_RESOLVER_local_fqdn_get ();
+  GNUNET_asprintf (&expected_uri,
+                   "http://%s:%u/",
+                   hostname != NULL ? hostname : "localhost",
+                   (unsigned int) port);
+  end = (const char *) &message[1];
+  current_adv_uri = GNUNET_strdup (end);
+  if (0 == strcmp (expected_uri,
+                   current_adv_uri))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Received hostlist advertisement with URI `%s' as expected\n",
+                current_adv_uri);
+    adv_arrived = GNUNET_YES;
+    adv_sent = GNUNET_YES;
+  }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-               "Expected URI `%s' and received URI `%s' differ\n",
-               expected_uri,
-               current_adv_uri);
-  GNUNET_free(expected_uri);
-  GNUNET_free_non_null(hostname);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected URI `%s' and received URI `%s' differ\n",
+                expected_uri,
+                current_adv_uri);
+  GNUNET_free (expected_uri);
+  GNUNET_free_non_null (hostname);
 }
 
 
 static void
-setup_learn_peer(struct PeerContext *p,
-                 const char *cfgname)
+setup_learn_peer (struct PeerContext *p,
+                  const char *cfgname)
 {
   struct GNUNET_MQ_MessageHandler learn_handlers[] = {
-    GNUNET_MQ_hd_var_size(ad_arrive,
-                          GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT,
-                          struct GNUNET_MessageHeader,
-                          NULL),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (ad_arrive,
+                           GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+    GNUNET_MQ_handler_end ()
   };
   char *filename;
   unsigned int result;
   char *binary;
 
-  binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm");
-  p->cfg = GNUNET_CONFIGURATION_create();
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
+  p->cfg = GNUNET_CONFIGURATION_create ();
   p->arm_proc =
-    GNUNET_OS_start_process(GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                            NULL, NULL, NULL,
-                            binary,
-                            "gnunet-service-arm",
-                            "-c", cfgname, NULL);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONFIGURATION_load(p->cfg,
-                                          cfgname));
+    GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                             NULL, NULL, NULL,
+                             binary,
+                             "gnunet-service-arm",
+                             "-c", cfgname, NULL);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (p->cfg,
+                                            cfgname));
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_string(p->cfg,
-                                            "HOSTLIST",
-                                            "HOSTLISTFILE",
-                                            &filename))
+      GNUNET_CONFIGURATION_get_value_string (p->cfg,
+                                             "HOSTLIST",
+                                             "HOSTLISTFILE",
+                                             &filename))
+  {
+    if (GNUNET_YES == GNUNET_DISK_file_test (filename))
     {
-      if (GNUNET_YES == GNUNET_DISK_file_test(filename))
-        {
-          result = unlink(filename);
-          if (result == 0)
-            GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                       _("Hostlist file `%s' was removed\n"),
-                       filename);
-        }
-      GNUNET_free(filename);
+      result = unlink (filename);
+      if (result == 0)
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    _ ("Hostlist file `%s' was removed\n"),
+                    filename);
     }
-  p->core = GNUNET_CORE_connect(p->cfg,
-                                NULL,
-                                NULL,
-                                NULL,
-                                NULL,
-                                learn_handlers);
-  GNUNET_assert(NULL != p->core);
-  p->stats = GNUNET_STATISTICS_create("hostlist",
-                                      p->cfg);
-  GNUNET_assert(NULL != p->stats);
-  GNUNET_free(binary);
+    GNUNET_free (filename);
+  }
+  p->core = GNUNET_CORE_connect (p->cfg,
+                                 NULL,
+                                 NULL,
+                                 NULL,
+                                 NULL,
+                                 learn_handlers);
+  GNUNET_assert (NULL != p->core);
+  p->stats = GNUNET_STATISTICS_create ("hostlist",
+                                       p->cfg);
+  GNUNET_assert (NULL != p->stats);
+  GNUNET_free (binary);
 }
 
 
 static void
-setup_adv_peer(struct PeerContext *p,
-               const char *cfgname)
+setup_adv_peer (struct PeerContext *p,
+                const char *cfgname)
 {
   char *binary;
 
-  binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm");
-  p->cfg = GNUNET_CONFIGURATION_create();
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
+  p->cfg = GNUNET_CONFIGURATION_create ();
   p->arm_proc =
-    GNUNET_OS_start_process(GNUNET_YES,
-                            GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                            NULL, NULL, NULL,
-                            binary,
-                            "gnunet-service-arm",
-                            "-c", cfgname, NULL);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONFIGURATION_load(p->cfg,
-                                          cfgname));
-  p->stats = GNUNET_STATISTICS_create("hostlist", p->cfg);
-  GNUNET_assert(NULL != p->stats);
-  GNUNET_free(binary);
+    GNUNET_OS_start_process (GNUNET_YES,
+                             GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                             NULL, NULL, NULL,
+                             binary,
+                             "gnunet-service-arm",
+                             "-c", cfgname, NULL);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (p->cfg,
+                                            cfgname));
+  p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
+  GNUNET_assert (NULL != p->stats);
+  GNUNET_free (binary);
 }
 
 
 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)
 {
   timeout = GNUNET_NO;
   adv_sent = GNUNET_NO;
@@ -486,22 +489,22 @@ run(void *cls,
 
   cfg = c;
 
-  setup_adv_peer(&adv_peer,
-                 "test_learning_adv_peer.conf");
-  setup_learn_peer(&learn_peer,
-                   "test_learning_learn_peer.conf");
-  timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
-                                              &timeout_error,
-                                              NULL);
+  setup_adv_peer (&adv_peer,
+                  "test_learning_adv_peer.conf");
+  setup_learn_peer (&learn_peer,
+                    "test_learning_learn_peer.conf");
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                               &timeout_error,
+                                               NULL);
   check_task =
-    GNUNET_SCHEDULER_add_delayed(CHECK_INTERVAL,
-                                 &check_statistics,
-                                 NULL);
+    GNUNET_SCHEDULER_add_delayed (CHECK_INTERVAL,
+                                  &check_statistics,
+                                  NULL);
 }
 
 
 static int
-check()
+check ()
 {
   unsigned int failed;
 
@@ -514,44 +517,44 @@ check()
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1,
-                     argv,
-                     "test-gnunet-daemon-hostlist-learning",
-                     "nohelp",
-                     options,
-                     &run,
-                     NULL);
+  GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1,
+                      argv,
+                      "test-gnunet-daemon-hostlist-learning",
+                      "nohelp",
+                      options,
+                      &run,
+                      NULL);
   failed = GNUNET_NO;
   if (timeout == GNUNET_YES)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Testcase timeout\n");
-      failed = GNUNET_YES;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Testcase timeout\n");
+    failed = GNUNET_YES;
+  }
   if (adv_arrived != GNUNET_YES)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Learning peer did not receive advertisement from server\n");
-      failed = GNUNET_YES;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Learning peer did not receive advertisement from server\n");
+    failed = GNUNET_YES;
+  }
   if (learned_hostlist_saved == GNUNET_NO)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Advertised hostlist was not saved in datastore\n");
-      failed = GNUNET_YES;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Advertised hostlist was not saved in datastore\n");
+    failed = GNUNET_YES;
+  }
   if (learned_hostlist_downloaded == GNUNET_NO)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Advertised hostlist could not be downloaded from server\n");
-      failed = GNUNET_YES;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Advertised hostlist could not be downloaded from server\n");
+    failed = GNUNET_YES;
+  }
   if (adv_sent == GNUNET_NO)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Advertised was not sent from server to client\n");
-      failed = GNUNET_YES;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Advertised was not sent from server to client\n");
+    failed = GNUNET_YES;
+  }
   if (GNUNET_YES == failed)
     return GNUNET_YES;
   return GNUNET_NO;
@@ -559,29 +562,29 @@ check()
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   int ret;
 
-  GNUNET_DISK_purge_cfg_dir("test_learning_learn_peer.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_learning_adv_peer.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_log_setup("test-gnunet-daemon-hostlist",
-                   "WARNING",
-                   NULL);
-  ret = check();
-  GNUNET_DISK_purge_cfg_dir("test_learning_learn_peer.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_learning_adv_peer.conf",
-                            "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_learning_learn_peer.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_learning_adv_peer.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_log_setup ("test-gnunet-daemon-hostlist",
+                    "WARNING",
+                    NULL);
+  ret = check ();
+  GNUNET_DISK_purge_cfg_dir ("test_learning_learn_peer.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_learning_adv_peer.conf",
+                             "GNUNET_TEST_HOME");
   if (GNUNET_YES ==
-      GNUNET_DISK_file_test("hostlists_learn_peer.file"))
-    {
-      if (0 == unlink("hostlists_learn_peer.file"))
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                   "Hostlist file hostlists_learn_peer.file was removed\n");
-    }
+      GNUNET_DISK_file_test ("hostlists_learn_peer.file"))
+  {
+    if (0 == unlink ("hostlists_learn_peer.file"))
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Hostlist file hostlists_learn_peer.file was removed\n");
+  }
   return ret;
 }
 
diff --git a/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c b/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c
index 783da1d20..ce17cfe4d 100644
--- a/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c
@@ -32,13 +32,14 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 150)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 150)
 
 static int ok;
 
 static struct GNUNET_SCHEDULER_Task *timeout_task;
 
-struct PeerContext {
+struct PeerContext
+{
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_TRANSPORT_CoreHandle *th;
   struct GNUNET_MessageHeader *hello;
@@ -55,12 +56,12 @@ static struct PeerContext p2;
  * Timeout, give up.
  */
 static void
-timeout_error(void *cls)
+timeout_error (void *cls)
 {
   timeout_task = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Timeout trying to connect peers, test failed.\n");
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout trying to connect peers, test failed.\n");
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -74,87 +75,87 @@ timeout_error(void *cls)
  * @return NULL
  */
 static void *
-notify_connect(void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               struct GNUNET_MQ_Handle *mq)
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected, shutting down.\n");
   ok = 0;
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
   return NULL;
 }
 
 
 static void
-process_hello(void *cls, const struct GNUNET_MessageHeader *message)
+process_hello (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *p = cls;
 
-  GNUNET_TRANSPORT_hello_get_cancel(p->ghh);
+  GNUNET_TRANSPORT_hello_get_cancel (p->ghh);
   p->ghh = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received HELLO, starting hostlist service.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received HELLO, starting hostlist service.\n");
 }
 
 
 static void
-setup_peer(struct PeerContext *p, const char *cfgname)
+setup_peer (struct PeerContext *p, const char *cfgname)
 {
   char *binary;
 
-  binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm");
-  p->cfg = GNUNET_CONFIGURATION_create();
-  p->arm_proc = GNUNET_OS_start_process(GNUNET_YES,
-                                        GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                        NULL,
-                                        NULL,
-                                        NULL,
-                                        binary,
-                                        "gnunet-service-arm",
-                                        "-c",
-                                        cfgname,
-                                        NULL);
-  GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_load(p->cfg, cfgname));
-  p->th = GNUNET_TRANSPORT_core_connect(p->cfg,
-                                        NULL,
-                                        NULL,
-                                        p,
-                                        &notify_connect,
-                                        NULL,
-                                        NULL);
-  GNUNET_assert(NULL != p->th);
-  p->ghh = GNUNET_TRANSPORT_hello_get(p->cfg,
-                                      GNUNET_TRANSPORT_AC_ANY,
-                                      &process_hello,
-                                      p);
-  GNUNET_free(binary);
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
+  p->cfg = GNUNET_CONFIGURATION_create ();
+  p->arm_proc = GNUNET_OS_start_process (GNUNET_YES,
+                                         GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                         NULL,
+                                         NULL,
+                                         NULL,
+                                         binary,
+                                         "gnunet-service-arm",
+                                         "-c",
+                                         cfgname,
+                                         NULL);
+  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
+                                         NULL,
+                                         NULL,
+                                         p,
+                                         &notify_connect,
+                                         NULL,
+                                         NULL);
+  GNUNET_assert (NULL != p->th);
+  p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
+                                       GNUNET_TRANSPORT_AC_ANY,
+                                       &process_hello,
+                                       p);
+  GNUNET_free (binary);
 }
 
 
 static void
-waitpid_task(void *cls)
+waitpid_task (void *cls)
 {
   struct PeerContext *p = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n");
-  if (0 != GNUNET_OS_process_kill(p->arm_proc, GNUNET_TERM_SIG))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
-  if (GNUNET_OK != GNUNET_OS_process_wait(p->arm_proc))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "waitpid");
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "ARM process %u stopped\n",
-             GNUNET_OS_process_get_pid(p->arm_proc));
-  GNUNET_OS_process_destroy(p->arm_proc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n");
+  if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OK != GNUNET_OS_process_wait (p->arm_proc))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ARM process %u stopped\n",
+              GNUNET_OS_process_get_pid (p->arm_proc));
+  GNUNET_OS_process_destroy (p->arm_proc);
   p->arm_proc = NULL;
-  GNUNET_CONFIGURATION_destroy(p->cfg);
+  GNUNET_CONFIGURATION_destroy (p->cfg);
 }
 
 
 static void
-stop_arm(struct PeerContext *p)
+stop_arm (struct PeerContext *p)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n");
-  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking ARM to stop core service\n");
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &waitpid_task, p);
 }
 
 
@@ -162,55 +163,55 @@ stop_arm(struct PeerContext *p)
  * Try again to connect to transport service.
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   if (NULL != timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
   if (NULL != p1.ghh)
-    {
-      GNUNET_TRANSPORT_hello_get_cancel(p1.ghh);
-      p1.ghh = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_hello_get_cancel (p1.ghh);
+    p1.ghh = NULL;
+  }
   if (NULL != p1.th)
-    {
-      GNUNET_TRANSPORT_core_disconnect(p1.th);
-      p1.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_core_disconnect (p1.th);
+    p1.th = NULL;
+  }
   if (NULL != p2.ghh)
-    {
-      GNUNET_TRANSPORT_hello_get_cancel(p2.ghh);
-      p2.ghh = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_hello_get_cancel (p2.ghh);
+    p2.ghh = NULL;
+  }
   if (NULL != p2.th)
-    {
-      GNUNET_TRANSPORT_core_disconnect(p2.th);
-      p2.th = NULL;
-    }
-  stop_arm(&p1);
-  stop_arm(&p2);
+  {
+    GNUNET_TRANSPORT_core_disconnect (p2.th);
+    p2.th = NULL;
+  }
+  stop_arm (&p1);
+  stop_arm (&p2);
 }
 
 
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  GNUNET_assert(ok == 1);
+  GNUNET_assert (ok == 1);
   ok++;
-  timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_error, NULL);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
-  setup_peer(&p1, "test_gnunet_daemon_hostlist_peer1.conf");
-  setup_peer(&p2, "test_gnunet_daemon_hostlist_peer2.conf");
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  setup_peer (&p1, "test_gnunet_daemon_hostlist_peer1.conf");
+  setup_peer (&p2, "test_gnunet_daemon_hostlist_peer2.conf");
 }
 
 
 int
-main(int argcx, char *argvx[])
+main (int argcx, char *argvx[])
 {
   static char *const argv[] = { "test-gnunet-daemon-hostlist",
                                 "-c",
@@ -220,41 +221,41 @@ main(int argcx, char *argvx[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_log_setup("test-gnunet-daemon-hostlist", "WARNING", NULL);
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_log_setup ("test-gnunet-daemon-hostlist", "WARNING", NULL);
   ok = 1;
-  GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1,
-                     argv,
-                     "test-gnunet-daemon-hostlist",
-                     "nohelp",
-                     options,
-                     &run,
-                     &ok);
+  GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1,
+                      argv,
+                      "test-gnunet-daemon-hostlist",
+                      "nohelp",
+                      options,
+                      &run,
+                      &ok);
   if (0 == ok)
-    {
-      fprintf(stderr, "%s", ".");
-      /* now do it again */
-      ok = 1;
-      GNUNET_PROGRAM_run((sizeof(argv) / sizeof(char *)) - 1,
-                         argv,
-                         "test-gnunet-daemon-hostlist",
-                         "nohelp",
-                         options,
-                         &run,
-                         &ok);
-      fprintf(stderr, "%s", ".\n");
-    }
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer1.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_peer2.conf",
-                            "GNUNET_TEST_HOME");
-  GNUNET_DISK_purge_cfg_dir("test_gnunet_daemon_hostlist_data.conf",
-                            "GNUNET_TEST_HOME");
+  {
+    fprintf (stderr, "%s", ".");
+    /* now do it again */
+    ok = 1;
+    GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1,
+                        argv,
+                        "test-gnunet-daemon-hostlist",
+                        "nohelp",
+                        options,
+                        &run,
+                        &ok);
+    fprintf (stderr, "%s", ".\n");
+  }
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer1.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_peer2.conf",
+                             "GNUNET_TEST_HOME");
+  GNUNET_DISK_purge_cfg_dir ("test_gnunet_daemon_hostlist_data.conf",
+                             "GNUNET_TEST_HOME");
   return ok;
 }