indentation

8 files changed, 1335 insertions, 1477 deletions

diff --git a/src/hostlist/gnunet-daemon-hostlist.c b/src/hostlist/gnunet-daemon-hostlist.c
index f409dc9a6..c49aec765 100644
--- a/src/hostlist/gnunet-daemon-hostlist.c
+++ b/src/hostlist/gnunet-daemon-hostlist.c
@@ -129,12 +129,9 @@ static struct GNUNET_PeerIdentity me;
 
 static void
 core_init (void *cls,
-           struct GNUNET_CORE_Handle * server,
-           const struct GNUNET_PeerIdentity *
-           my_identity,
-           const struct
-           GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
-           publicKey)
+           struct GNUNET_CORE_Handle *server,
+           const struct GNUNET_PeerIdentity *my_identity,
+           const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 {
   me = *my_identity;
 }
@@ -142,10 +139,11 @@ core_init (void *cls,
 /**
  * Core handler for p2p hostlist advertisements
  */
-static int advertisement_handler (void *cls,
-                                  const struct GNUNET_PeerIdentity * peer,
-                                  const struct GNUNET_MessageHeader * message,
-                                  const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+static int
+advertisement_handler (void *cls,
+                       const struct GNUNET_PeerIdentity *peer,
+                       const struct GNUNET_MessageHeader *message,
+                       const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_assert (NULL != client_adv_handler);
   return (*client_adv_handler) (cls, peer, message, atsi);
@@ -162,17 +160,17 @@ static int advertisement_handler (void *cls,
 static void
 connect_handler (void *cls,
                  const struct
-                 GNUNET_PeerIdentity * peer,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 GNUNET_PeerIdentity *peer,
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   if (0 == memcmp (&me, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "A new peer connected, notifying client and server\n");
-  if ( NULL != client_ch)
+  if (NULL != client_ch)
     (*client_ch) (cls, peer, atsi);
 #if HAVE_MHD
-  if ( NULL != server_ch)
+  if (NULL != server_ch)
     (*server_ch) (cls, peer, atsi);
 #endif
 }
@@ -184,18 +182,16 @@ connect_handler (void *cls,
  * @param peer peer identity this notification is about
  */
 static void
-disconnect_handler (void *cls,
-                    const struct
-                    GNUNET_PeerIdentity * peer)
+disconnect_handler (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   if (0 == memcmp (&me, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
-  /* call hostlist client disconnect handler*/
-  if ( NULL != client_dh)
+  /* call hostlist client disconnect handler */
+  if (NULL != client_dh)
     (*client_dh) (cls, peer);
 #if HAVE_MHD
-  /* call hostlist server disconnect handler*/
-  if ( NULL != server_dh)
+  /* call hostlist server disconnect handler */
+  if (NULL != server_dh)
     (*server_dh) (cls, peer);
 #endif
 }
@@ -207,29 +203,27 @@ disconnect_handler (void *cls,
 static void
 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  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 (core != NULL)
-    {
-      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 (stats != NULL)
-    {
-      GNUNET_STATISTICS_destroy (stats,
-                                 GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }
 }
 
 
@@ -241,67 +235,67 @@ cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param cfg configuration
  */
-static void 
+static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle * cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   static const struct GNUNET_CORE_MessageHandler learn_handlers[] = {
-    { &advertisement_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
-    { NULL, 0, 0 }
+    {&advertisement_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
+    {NULL, 0, 0}
   };
   static const struct GNUNET_CORE_MessageHandler no_learn_handlers[] = {
-    { NULL, 0, 0 }
+    {NULL, 0, 0}
   };
-  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;
-    }
+      )
+  {
+    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);
 
   core = GNUNET_CORE_connect (cfg,
-                              1,
-                              NULL,
-                              &core_init,
-                              &connect_handler, &disconnect_handler, NULL,
-                              NULL, GNUNET_NO,
-                              NULL, GNUNET_NO,
-                              learning? learn_handlers : no_learn_handlers);
+                              1,
+                              NULL,
+                              &core_init,
+                              &connect_handler, &disconnect_handler, NULL,
+                              NULL, GNUNET_NO,
+                              NULL, GNUNET_NO,
+                              learning ? learn_handlers : no_learn_handlers);
 
   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);
+  }
 
-  #if HAVE_MHD
+#if HAVE_MHD
   if (provide_hostlist)
-    {      
-      GNUNET_HOSTLIST_server_start (cfg, stats, core, &server_ch, &server_dh, advertising );
-    }
+  {
+    GNUNET_HOSTLIST_server_start (cfg, stats, core, &server_ch, &server_dh,
+                                  advertising);
+  }
 #endif
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &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;
+  }
 }
 
 
@@ -317,33 +311,34 @@ main (int argc, char *const *argv)
 {
   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 #if HAVE_MHD
-    { 'a', "advertise", NULL, 
-      gettext_noop ("advertise our hostlist to other peers"),
-      GNUNET_NO, &GNUNET_GETOPT_set_one, &advertising },
+    {'a', "advertise", NULL,
+     gettext_noop ("advertise our hostlist to other peers"),
+     GNUNET_NO, &GNUNET_GETOPT_set_one, &advertising},
 #endif
-    { 'b', "bootstrap", NULL, 
-      gettext_noop ("bootstrap using hostlists (it is highly recommended that you always use this option)"),
-      GNUNET_NO, &GNUNET_GETOPT_set_one, &bootstrapping },
-    { 'e', "enable-learning", NULL,
-      gettext_noop ("enable learning about hostlist servers from other peers"),
-      GNUNET_NO, &GNUNET_GETOPT_set_one, &learning},
+    {'b', "bootstrap", NULL,
+     gettext_noop
+     ("bootstrap using hostlists (it is highly recommended that you always use this option)"),
+     GNUNET_NO, &GNUNET_GETOPT_set_one, &bootstrapping},
+    {'e', "enable-learning", NULL,
+     gettext_noop ("enable learning about hostlist servers from other peers"),
+     GNUNET_NO, &GNUNET_GETOPT_set_one, &learning},
 #if HAVE_MHD
-    { 'p', "provide-hostlist", NULL, 
-      gettext_noop ("provide a hostlist server"),
-      GNUNET_NO, &GNUNET_GETOPT_set_one, &provide_hostlist},
+    {'p', "provide-hostlist", NULL,
+     gettext_noop ("provide a hostlist server"),
+     GNUNET_NO, &GNUNET_GETOPT_set_one, &provide_hostlist},
 #endif
     GNUNET_GETOPT_OPTION_END
   };
 
   int ret;
+
   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;
+                             "hostlist",
+                             _("GNUnet hostlist server and client"),
+                             options, &run, NULL)) ? 0 : 1;
 
   return ret;
 }
diff --git a/src/hostlist/hostlist-client.c b/src/hostlist/hostlist-client.c
index f104e79d4..422855f0e 100644
--- a/src/hostlist/hostlist-client.c
+++ b/src/hostlist/hostlist-client.c
@@ -58,12 +58,12 @@ struct Hostlist
   /**
    * previous entry, used to manage entries in a double linked list
    */
-  struct Hostlist * prev;
+  struct Hostlist *prev;
 
   /**
    * next entry, used to manage entries in a double linked list
    */
-  struct Hostlist * next;
+  struct Hostlist *next;
 
   /**
    * URI where hostlist can be obtained
@@ -111,13 +111,13 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
 /**
  * Statistics handle.
  */
-static struct GNUNET_STATISTICS_Handle *stats; 
+static struct GNUNET_STATISTICS_Handle *stats;
 
 /**
  * Transport handle.
  */
 static struct GNUNET_TRANSPORT_Handle *transport;
-                       
+
 /**
  * Proxy that we are using (can be NULL).
  */
@@ -186,17 +186,17 @@ static struct GNUNET_TIME_Absolute end_time;
 /**
  * Head of the linked list used to store hostlists
  */
-static struct Hostlist * linked_list_head;
+static struct Hostlist *linked_list_head;
 
 /**
  *  Tail of the linked list used to store hostlists
  */
-static struct Hostlist * linked_list_tail;
+static struct Hostlist *linked_list_tail;
 
 /**
  *  Current hostlist used for downloading
  */
-static struct Hostlist * current_hostlist;
+static struct Hostlist *current_hostlist;
 
 /**
  *  Size of the linke list  used to store hostlists
@@ -206,7 +206,7 @@ static unsigned int linked_list_size;
 /**
  * Head of the linked list used to store hostlists
  */
-static struct Hostlist * hostlist_to_test;
+static struct Hostlist *hostlist_to_test;
 
 /**
  * Set to GNUNET_YES if the current URL had some problems.
@@ -232,6 +232,7 @@ static int stat_download_in_progress;
  * Value saying if a preconfigured bootstrap server is used
  */
 static unsigned int stat_use_bootstrap;
+
 /**
  * Set if we are allowed to learn new hostlists and use them
  */
@@ -263,13 +264,10 @@ static unsigned int stat_connection_count;
  * @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_SERVER_MAX_MESSAGE_SIZE - 1];
-  const char * cbuf = ptr;
+  const char *cbuf = ptr;
   const struct GNUNET_MessageHeader *msg;
   size_t total;
   size_t cpy;
@@ -278,85 +276,78 @@ callback_download (void *ptr,
 
   total = size * nmemb;
   stat_bytes_downloaded += total;
-  if ( (total == 0) || (stat_bogus_url) )
-    {
-      return total;  /* ok, no data or bogus data */
-    }
+  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);  
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop
+                            ("# bytes downloaded from hostlist servers"),
+                            (int64_t) total, GNUNET_NO);
   left = total;
-  while ( (left > 0) ||
-          (download_pos > 0) )
+  while ((left > 0) || (download_pos > 0))
+  {
+    cpy = GNUNET_MIN (left, GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - download_pos);
+    memcpy (&download_buffer[download_pos], cbuf, cpy);
+    cbuf += cpy;
+    download_pos += cpy;
+    left -= cpy;
+    if (download_pos < sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_assert (left == 0);
+      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)
     {
-      cpy = GNUNET_MIN (left, GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - download_pos);
-      memcpy (&download_buffer[download_pos],
-              cbuf,
-              cpy);      
-      cbuf += cpy;
-      download_pos += cpy;
-      left -= cpy;
-      if (download_pos < sizeof(struct GNUNET_MessageHeader))
-        {
-          GNUNET_assert (left == 0);
-          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)
-        {
 #if DEBUG_HOSTLIST_CLIENT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Received valid `%s' message from hostlist server.\n",
-                      "HELLO");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Received valid `%s' message from hostlist server.\n",
+                  "HELLO");
 #endif
-          GNUNET_STATISTICS_update (stats, 
-                                    gettext_noop ("# valid HELLOs downloaded from hostlist servers"), 
-                                    1, 
-                                    GNUNET_NO);
-          stat_hellos_obtained++;
-          GNUNET_TRANSPORT_offer_hello (transport, 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_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# valid HELLOs downloaded from hostlist servers"),
+                                1, GNUNET_NO);
+      stat_hellos_obtained++;
+      GNUNET_TRANSPORT_offer_hello (transport, 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;
 }
 
@@ -374,55 +365,55 @@ get_bootstrap_server ()
   size_t urls;
   size_t pos;
 
-  if (GNUNET_OK != 
+  if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "HOSTLIST",
-                                             "SERVERS",
-                                             &servers))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("No `%s' specified in `%s' configuration, will not bootstrap.\n"),
-                  "SERVERS", "HOSTLIST");
-      return NULL;
-    }
+                                             "HOSTLIST", "SERVERS", &servers))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("No `%s' specified in `%s' configuration, will not bootstrap.\n"),
+                "SERVERS", "HOSTLIST");
+    return NULL;
+  }
 
   urls = 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 (GNUNET_ERROR_TYPE_WARNING,
-                  _("No `%s' specified in `%s' configuration, will not bootstrap.\n"),
-                  "SERVERS", "HOSTLIST");
-      GNUNET_free (servers);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("No `%s' specified in `%s' configuration, will not bootstrap.\n"),
+                "SERVERS", "HOSTLIST");
+    GNUNET_free (servers);
+    return NULL;
+  }
 
   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;
+    }
+    pos--;
+  }
   ret = GNUNET_strdup (&servers[pos]);
   GNUNET_free (servers);
   return ret;
@@ -437,45 +428,44 @@ download_get_url ()
 {
   uint32_t index;
   unsigned int counter;
-  struct Hostlist * pos;
+  struct Hostlist *pos;
 
-  if ( GNUNET_NO == stat_learning)
+  if (GNUNET_NO == stat_learning)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Using preconfigured bootstrap server\n");
     current_hostlist = NULL;
-    return get_bootstrap_server();
+    return get_bootstrap_server ();
   }
 
-  if ( ( GNUNET_YES == stat_testing_hostlist) && (NULL != hostlist_to_test) )
+  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 strdup(hostlist_to_test->hostlist_uri);
+    return strdup (hostlist_to_test->hostlist_uri);
   }
 
-  if ( (GNUNET_YES == stat_use_bootstrap) ||
-       (linked_list_size == 0) )
+  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();
+    return get_bootstrap_server ();
   }
-  index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 
-                                    linked_list_size);
+  index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                    linked_list_size);
   counter = 0;
   pos = linked_list_head;
-  while ( counter < index )
-    {
-      pos = pos->next;
-      counter ++;
-    }
+  while (counter < index)
+  {
+    pos = pos->next;
+    counter++;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Using learned hostlist `%s'\n", pos->hostlist_uri);
   current_hostlist = pos;
-  return strdup(pos->hostlist_uri);
+  return strdup (pos->hostlist_uri);
 }
 
 
@@ -486,7 +476,7 @@ download_get_url ()
  * Method to save hostlist to a file during hostlist client shutdown
  * @param shutdown set if called because of shutdown, entries in linked list will be destroyed
  */
-static void save_hostlist_file ( int shutdown );
+static void save_hostlist_file (int shutdown);
 
 
 /**
@@ -495,7 +485,8 @@ static void save_hostlist_file ( int shutdown );
  * @param val2 value 2
  * @return result
  */
-static uint64_t checked_add (uint64_t val1, uint64_t val2)
+static uint64_t
+checked_add (uint64_t val1, uint64_t val2)
 {
   static uint64_t temp;
   static uint64_t maxv;
@@ -503,8 +494,8 @@ static uint64_t checked_add (uint64_t val1, uint64_t val2)
   maxv = 0;
   maxv--;
 
-  temp = val1+val2;
-  if ( temp < val1)
+  temp = val1 + val2;
+  if (temp < val1)
     return maxv;
   else
     return temp;
@@ -516,14 +507,13 @@ static uint64_t checked_add (uint64_t val1, uint64_t val2)
  * @param val2 value 2
  * @return result
  */
-static uint64_t 
-checked_sub (uint64_t val1, 
-             uint64_t val2)
+static uint64_t
+checked_sub (uint64_t val1, uint64_t val2)
 {
-  if ( val1 <= val2)
+  if (val1 <= val2)
     return 0;
   else
-    return (val1-val2);
+    return (val1 - val2);
 }
 
 /**
@@ -532,17 +522,17 @@ checked_sub (uint64_t val1,
  * @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;
+  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;
 }
 
@@ -552,21 +542,21 @@ 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;
+  struct Hostlist *pos;
+  struct Hostlist *lowest;
 
   if (linked_list_size == 0)
     return NULL;
   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;
 }
 
@@ -579,29 +569,28 @@ linked_list_get_lowest_quality ( )
 static void
 insert_hostlist ()
 {
-  struct Hostlist * lowest_quality;
+  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);
+                         gettext_noop ("# advertised hostlist URIs"),
+                         linked_list_size, GNUNET_NO);
   stat_testing_hostlist = GNUNET_NO;
 }
 
@@ -609,33 +598,36 @@ insert_hostlist ()
 /**
  * Method updating hostlist statistics
  */
-static void update_hostlist ( )
+static void
+update_hostlist ()
 {
   char *stat;
-  if ( ((stat_use_bootstrap == GNUNET_NO) && ( NULL != current_hostlist )) ||
-       ((stat_testing_hostlist == GNUNET_YES) && ( NULL != current_hostlist )) )
+
+  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 )
-     {
-       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 );
+                "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)
+    {
+      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);
   }
   current_hostlist = NULL;
   /* Alternating the usage of preconfigured and learned hostlists */
@@ -643,13 +635,13 @@ static void update_hostlist ( )
   if (stat_testing_hostlist == GNUNET_YES)
     return;
 
-  if ( GNUNET_YES == stat_learning)
-    {
+  if (GNUNET_YES == stat_learning)
+  {
     if (stat_use_bootstrap == GNUNET_YES)
       stat_use_bootstrap = GNUNET_NO;
     else
       stat_use_bootstrap = GNUNET_YES;
-    }
+  }
   else
     stat_use_bootstrap = GNUNET_YES;
 }
@@ -658,53 +650,53 @@ static void update_hostlist ( )
  * Clean up the state from the task that downloaded the
  * hostlist and schedule the next task.
  */
-static void 
+static void
 clean_up ()
 {
   CURLMcode mret;
 
-  if ( (stat_testing_hostlist == GNUNET_YES) && 
-       (GNUNET_NO == stat_download_successful) &&
-       (NULL != hostlist_to_test))
+  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);
+                _
+                ("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;
-    }
-  if ( NULL != hostlist_to_test)
+  {
+    stat_testing_hostlist = GNUNET_NO;
+  }
+  if (NULL != hostlist_to_test)
   {
     GNUNET_free (hostlist_to_test);
     hostlist_to_test = NULL;
   }
 
   if (multi != NULL)
+  {
+    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 (curl != NULL)
-    {
-      curl_easy_cleanup (curl);
-      curl = NULL;
-    }  
+  {
+    curl_easy_cleanup (curl);
+    curl = NULL;
+  }
   GNUNET_free_non_null (current_url);
   current_url = NULL;
   stat_bytes_downloaded = 0;
@@ -720,8 +712,7 @@ clean_up ()
  * @param tc task context, unused
  */
 static void
-task_download (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc);
+task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -747,27 +738,28 @@ download_prepare ()
   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;
-    }
+  {
+    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));
+  {
+    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);
@@ -777,13 +769,9 @@ download_prepare ()
               "Scheduling task for hostlist download using cURL\n");
 #endif
   ti_download
-    = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                   GNUNET_SCHEDULER_NO_TASK,
-                                   rtime,
-                                   grs,
-                                   gws,
-                                   &task_download,
-                                   multi);
+      = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     rtime, grs, gws, &task_download, multi);
   GNUNET_NETWORK_fdset_destroy (gws);
   GNUNET_NETWORK_fdset_destroy (grs);
 }
@@ -797,108 +785,107 @@ download_prepare ()
  * @param tc task context, unused
  */
 static void
-task_download (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   int running;
   struct CURLMsg *msg;
   CURLMcode mret;
-  
+
   ti_download = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    {
+  {
 #if DEBUG_HOSTLIST_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Shutdown requested while trying to download hostlist from `%s'\n",
-                  current_url);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Shutdown requested while trying to download hostlist from `%s'\n",
+                current_url);
 #endif
-      update_hostlist();
-      clean_up ();
-      return;
-    }
+    update_hostlist ();
+    clean_up ();
+    return;
+  }
   if (GNUNET_TIME_absolute_get_remaining (end_time).rel_value == 0)
-    {
-      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_WARNING,
+                _("Timeout trying to download hostlist from `%s'\n"),
+                current_url);
+    update_hostlist ();
+    clean_up ();
+    return;
+  }
 #if DEBUG_HOSTLIST_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Ready for processing hostlist client request\n");
+              "Ready for processing hostlist client request\n");
 #endif
 
-  do 
+  do
+  {
+    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)
     {
-      running = 0;
-      if (stat_bytes_downloaded > MAX_BYTES_PER_HOSTLISTS)
+      do
+      {
+        msg = curl_multi_info_read (multi, &running);
+        GNUNET_break (msg != NULL);
+        if (msg == NULL)
+          break;
+        switch (msg->msg)
         {
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                    _("Download limit of %u bytes exceeded, stopping download\n"),
-                    MAX_BYTES_PER_HOSTLISTS);
-        clean_up();
-        return;
+        case CURLMSG_DONE:
+          if ((msg->data.result != CURLE_OK) &&
+              (msg->data.result != CURLE_GOT_NOTHING))
+            GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                        _("%s failed for `%s' at %s:%d: `%s'\n"),
+                        "curl_multi_perform",
+                        current_url,
+                        __FILE__,
+                        __LINE__, 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;
         }
-      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)
-                {
-                case CURLMSG_DONE:
-                  if ( (msg->data.result != CURLE_OK) &&
-                       (msg->data.result != CURLE_GOT_NOTHING) )                       
-                    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                               _("%s failed for `%s' at %s:%d: `%s'\n"),
-                               "curl_multi_perform", 
-                               current_url,
-                               __FILE__,
-                               __LINE__,
-                               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;
-                }
-
-            }
-          while ( (running > 0) );
-        }
+
+      }
+      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 ();
-    }
+  {
+    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 ();
 }
 
@@ -908,7 +895,7 @@ task_download (void *cls,
  * data.
  */
 static void
-download_hostlist () 
+download_hostlist ()
 {
   CURLcode ret;
   CURLMcode mret;
@@ -920,132 +907,110 @@ download_hostlist ()
   curl = curl_easy_init ();
   multi = NULL;
   if (curl == NULL)
-    {
-      GNUNET_break (0);
-      clean_up ();
-      return;
-    }
+  {
+    GNUNET_break (0);
+    clean_up ();
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
-              _("Bootstrapping using hostlist at `%s'.\n"), 
-              current_url);
+              _("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 (proxy != NULL)
-    CURL_EASY_SETOPT (curl, CURLOPT_PROXY, proxy);    
+    CURL_EASY_SETOPT (curl, CURLOPT_PROXY, proxy);
   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;
-    }
+  {
+    clean_up ();
+    return;
+  }
   CURL_EASY_SETOPT (curl, CURLOPT_FOLLOWLOCATION, 1);
   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_SERVER_MAX_MESSAGE_SIZE);
+  CURL_EASY_SETOPT (curl, CURLOPT_BUFFERSIZE, GNUNET_SERVER_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);
+  CURL_EASY_SETOPT (curl, CURLOPT_CONNECTTIMEOUT, 60L);
+  CURL_EASY_SETOPT (curl, CURLOPT_TIMEOUT, 60L);
 #if 0
   /* this should no longer be needed; we're now single-threaded! */
-  CURL_EASY_SETOPT (curl,
-                    CURLOPT_NOSIGNAL, 
-                    1);
+  CURL_EASY_SETOPT (curl, CURLOPT_NOSIGNAL, 1);
 #endif
   multi = curl_multi_init ();
   if (multi == NULL)
-    {
-      GNUNET_break (0);
-      /* clean_up (); */
-      return;
-    }
+  {
+    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_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;
-    }
+                  _("%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,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+                          const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ti_download_dispatcher_task = GNUNET_SCHEDULER_NO_TASK;
-    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-      return;
-   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();
-   }
-   else
-   {
-     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-               "Download in progess, have to wait...\n");
-     ti_download_dispatcher_task = GNUNET_SCHEDULER_add_delayed (WAITING_INTERVALL,
-                                                              &task_download_dispatcher,
-                                                              NULL);
-   }
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
+  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 ();
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Download in progess, have to wait...\n");
+    ti_download_dispatcher_task =
+        GNUNET_SCHEDULER_add_delayed (WAITING_INTERVALL,
+                                      &task_download_dispatcher, NULL);
+  }
 }
 
 /**
@@ -1054,8 +1019,7 @@ task_download_dispatcher (void *cls,
  * this task again for a later time.
  */
 static void
-task_check (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   static int once;
   struct GNUNET_TIME_Relative delay;
@@ -1066,40 +1030,40 @@ task_check (void *cls,
 
   if (stat_connection_count < MIN_CONNECTIONS)
   {
-    ti_download_dispatcher_task = GNUNET_SCHEDULER_add_now (&task_download_dispatcher,
-                                                          NULL);
+    ti_download_dispatcher_task =
+        GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL);
   }
 
   if (stats == NULL)
   {
     curl_global_cleanup ();
-    return; /* in shutdown */
+    return;                     /* in shutdown */
   }
   delay = hostlist_delay;
   if (hostlist_delay.rel_value == 0)
     hostlist_delay = GNUNET_TIME_UNIT_SECONDS;
   else
     hostlist_delay = GNUNET_TIME_relative_multiply (hostlist_delay, 2);
-  if (hostlist_delay.rel_value > GNUNET_TIME_UNIT_HOURS.rel_value * (1 + stat_connection_count))
-    hostlist_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS,
-                                                    (1 + stat_connection_count));
+  if (hostlist_delay.rel_value >
+      GNUNET_TIME_UNIT_HOURS.rel_value * (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,
-                         GNUNET_YES);
+                         gettext_noop
+                         ("# milliseconds between hostlist downloads"),
+                         hostlist_delay.rel_value, GNUNET_YES);
   if (0 == once)
-    {
-      delay = GNUNET_TIME_UNIT_ZERO;
-      once = 1;
-    }  
+  {
+    delay = GNUNET_TIME_UNIT_ZERO;
+    once = 1;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Have %u/%u connections.  Will consider downloading hostlist in %llums\n"),
-              stat_connection_count,
-              MIN_CONNECTIONS,
+              _
+              ("Have %u/%u connections.  Will consider downloading hostlist in %llums\n"),
+              stat_connection_count, MIN_CONNECTIONS,
               (unsigned long long) delay.rel_value);
-  ti_check_download = GNUNET_SCHEDULER_add_delayed (delay,
-                                               &task_check,
-                                               NULL);
+  ti_check_download = GNUNET_SCHEDULER_add_delayed (delay, &task_check, NULL);
 }
 
 
@@ -1111,14 +1075,14 @@ task_check (void *cls,
  */
 static void
 task_testing_intervall_reset (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+                              const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ti_testing_intervall_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
-   stat_testing_allowed = GNUNET_OK;
-   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Testing new hostlist advertisements is allowed again\n");
+  stat_testing_allowed = GNUNET_OK;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testing new hostlist advertisements is allowed again\n");
 }
 
 
@@ -1129,22 +1093,19 @@ task_testing_intervall_reset (void *cls,
  * @param tc TaskContext
  */
 static void
-task_hostlist_saving (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_hostlist_saving (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ti_saving_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Scheduled saving of hostlists\n"));
-  save_hostlist_file ( GNUNET_NO );
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Scheduled saving of hostlists\n"));
+  save_hostlist_file (GNUNET_NO);
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _("Hostlists will be saved to file again in %llums\n"),
               (unsigned long long) SAVING_INTERVALL.rel_value);
   ti_saving_task = GNUNET_SCHEDULER_add_delayed (SAVING_INTERVALL,
-                                               &task_hostlist_saving,
-                                               NULL);
+                                                 &task_hostlist_saving, NULL);
 }
 
 
@@ -1157,16 +1118,15 @@ task_hostlist_saving (void *cls,
  */
 static void
 handler_connect (void *cls,
-                 const struct
-                 GNUNET_PeerIdentity * peer,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 const struct
+                 GNUNET_PeerIdentity *peer,
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   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);
 }
 
 
@@ -1177,16 +1137,13 @@ handler_connect (void *cls,
  * @param peer peer identity this notification is about
  */
 static void
-handler_disconnect (void *cls,
-                    const struct
-                    GNUNET_PeerIdentity * peer)
+handler_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   GNUNET_assert (stat_connection_count > 0);
   stat_connection_count--;
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# active connections"),
-                            -1,
-                            GNUNET_NO);
+                            gettext_noop ("# active connections"),
+                            -1, GNUNET_NO);
 }
 
 
@@ -1202,76 +1159,74 @@ handler_disconnect (void *cls,
  */
 static int
 handler_advertisement (void *cls,
-                       const struct GNUNET_PeerIdentity * peer,
-                       const struct GNUNET_MessageHeader * message,
-                       const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                       const struct GNUNET_PeerIdentity *peer,
+                       const struct GNUNET_MessageHeader *message,
+                       const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   size_t size;
   size_t uri_size;
-  const struct GNUNET_MessageHeader * incoming;
+  const struct GNUNET_MessageHeader *incoming;
   const char *uri;
-  struct Hostlist * hostlist;
+  struct Hostlist *hostlist;
 
-  GNUNET_assert (ntohs (message->type) == GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
+  GNUNET_assert (ntohs (message->type) ==
+                 GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
   size = ntohs (message->size);
-  if (size <= sizeof(struct GNUNET_MessageHeader))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  if (size <= sizeof (struct GNUNET_MessageHeader))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   incoming = (const struct GNUNET_MessageHeader *) message;
-  uri = (const char*) &incoming[1];
+  uri = (const char *) &incoming[1];
   uri_size = size - sizeof (struct GNUNET_MessageHeader);
-  if (uri [uri_size - 1] != '\0')
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  if (uri[uri_size - 1] != '\0')
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Hostlist client recieved advertisement from `%s' containing URI `%s'\n", 
-              GNUNET_i2s (peer), 
-              uri);
+              "Hostlist client recieved advertisement from `%s' containing URI `%s'\n",
+              GNUNET_i2s (peer), uri);
   if (GNUNET_NO != linked_list_contains (uri))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "URI `%s' is already known\n",
-                uri);
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri);
+    return GNUNET_OK;
+  }
 
-  if ( GNUNET_NO == stat_testing_allowed )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+  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_SYSERR;
-    }
-  if ( GNUNET_YES == stat_testing_hostlist )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+    return GNUNET_SYSERR;
+  }
+  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_SYSERR;
-    }
+    return GNUNET_SYSERR;
+  }
 
   hostlist = GNUNET_malloc (sizeof (struct Hostlist) + uri_size);
-  hostlist->hostlist_uri = (const char*) &hostlist[1];
+  hostlist->hostlist_uri = (const char *) &hostlist[1];
   memcpy (&hostlist[1], uri, uri_size);
-  hostlist->time_creation = GNUNET_TIME_absolute_get();
-  hostlist->time_last_usage = GNUNET_TIME_absolute_get_zero();
+  hostlist->time_creation = GNUNET_TIME_absolute_get ();
+  hostlist->time_last_usage = GNUNET_TIME_absolute_get_zero ();
   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);
+                                                            &task_testing_intervall_reset,
+                                                            NULL);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-            "Testing new hostlist advertisements is locked for the next %u ms\n",
-            TESTING_INTERVAL.rel_value);
+              "Testing new hostlist advertisements is locked for the next %u ms\n",
+              TESTING_INTERVAL.rel_value);
 
-  ti_download_dispatcher_task = GNUNET_SCHEDULER_add_now (&task_download_dispatcher,
-                                                     NULL);
+  ti_download_dispatcher_task =
+      GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL);
 
   return GNUNET_OK;
 }
@@ -1290,26 +1245,23 @@ static void
 primary_task (void *cls, int success)
 {
   if (stats == NULL)
-    return; /* in shutdown */
+    return;                     /* in shutdown */
 #if DEBUG_HOSTLIST_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Statistics request done, scheduling hostlist download\n");
+              "Statistics request done, scheduling hostlist download\n");
 #endif
-  ti_check_download = GNUNET_SCHEDULER_add_now (&task_check,
-                                           NULL);
+  ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL);
 }
 
 
 static int
 process_stat (void *cls,
-              const char *subsystem,
-              const char *name,
-              uint64_t value,
-              int is_persistent)
+              const char *subsystem,
+              const char *name, uint64_t value, int is_persistent)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Initial time between hostlist downloads is %llums\n"),
-              (unsigned long long) value);
+              _("Initial time between hostlist downloads is %llums\n"),
+              (unsigned long long) value);
   hostlist_delay.rel_value = value;
   return GNUNET_OK;
 }
@@ -1317,13 +1269,14 @@ process_stat (void *cls,
 /**
  * Method to load persistent hostlist file during hostlist client startup
  */
-static void 
+static void
 load_hostlist_file ()
 {
   char *filename;
   char *uri;
   char *emsg;
-  struct Hostlist * hostlist;
+  struct Hostlist *hostlist;
+
   uri = NULL;
   uint32_t times_used;
   uint32_t hellos_returned;
@@ -1333,74 +1286,75 @@ load_hostlist_file ()
   uint32_t counter;
 
   if (GNUNET_OK !=
-                  GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                   "HOSTLIST",
-                                                   "HOSTLISTFILE",
-                                                   &filename))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("No `%s' specified in `%s' configuration, cannot load hostlists from file.\n"),
-                  "HOSTLISTFILE", "HOSTLIST");
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                               "HOSTLIST",
+                                               "HOSTLISTFILE", &filename))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("No `%s' specified in `%s' configuration, cannot load hostlists from file.\n"),
+                "HOSTLISTFILE", "HOSTLIST");
+    return;
+  }
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _("Loading saved hostlist entries from file `%s' \n"), filename);
-  if ( GNUNET_NO == GNUNET_DISK_file_test (filename) )
+  if (GNUNET_NO == GNUNET_DISK_file_test (filename))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _("Hostlist file `%s' is not existing\n"), filename);
-    GNUNET_free ( filename );
+    GNUNET_free (filename);
     return;
   }
 
-  struct GNUNET_BIO_ReadHandle * rh = GNUNET_BIO_read_open (filename);
+  struct GNUNET_BIO_ReadHandle *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)) &&
-          (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];
-      memcpy (&hostlist[1], uri, strlen(uri)+1);
-      hostlist->quality = quality;
-      hostlist->time_creation.abs_value = created;
-      hostlist->time_last_usage.abs_value = 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;
-    }
+  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];
+    memcpy (&hostlist[1], uri, strlen (uri) + 1);
+    hostlist->quality = quality;
+    hostlist->time_creation.abs_value = created;
+    hostlist->time_last_usage.abs_value = 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);
+                         gettext_noop ("# hostlist URIs read from file"),
+                         counter, GNUNET_YES);
   GNUNET_STATISTICS_set (stats,
-                         gettext_noop("# advertised hostlist URIs"),
-                         linked_list_size,
-                         GNUNET_NO);
+                         gettext_noop ("# advertised hostlist URIs"),
+                         linked_list_size, GNUNET_NO);
 
   GNUNET_free_non_null (uri);
   emsg = NULL;
@@ -1415,89 +1369,87 @@ load_hostlist_file ()
  * Method to save persistent hostlist file during hostlist client shutdown
  * @param shutdown set if called because of shutdown, entries in linked list will be destroyed
  */
-static void save_hostlist_file ( int shutdown )
+static void
+save_hostlist_file (int shutdown)
 {
   char *filename;
   struct Hostlist *pos;
-  struct GNUNET_BIO_WriteHandle * wh;
+  struct GNUNET_BIO_WriteHandle *wh;
   int ok;
   uint32_t counter;
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                             "HOSTLIST",
-                                             "HOSTLISTFILE",
-                                             &filename))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("No `%s' specified in `%s' configuration, cannot save hostlists to file.\n"),
-                  "HOSTLISTFILE", "HOSTLIST");
-      return;
-    }
+                                               "HOSTLIST",
+                                               "HOSTLISTFILE", &filename))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("No `%s' specified in `%s' configuration, cannot save hostlists to file.\n"),
+                "HOSTLISTFILE", "HOSTLIST");
+    return;
+  }
   if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
-    {
-      GNUNET_free (filename);
-      return;
-    }
+  {
+    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;
-    }
+  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" ),
+              _("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)
+    {
+      GNUNET_CONTAINER_DLL_remove (linked_list_head, linked_list_tail, pos);
+      linked_list_size--;
+    }
+    if (GNUNET_YES == ok)
     {
-      if ( GNUNET_YES == shutdown)
+      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)) ||
+          (GNUNET_OK !=
+           GNUNET_BIO_write_int64 (wh, pos->time_creation.abs_value)) ||
+          (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pos->hello_count)))
       {
-        GNUNET_CONTAINER_DLL_remove (linked_list_head, linked_list_tail, pos);
-        linked_list_size--;
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _("Error writing hostlist URIs to file `%s'\n"), filename);
+        ok = GNUNET_NO;
       }
-      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)) ||
-               (GNUNET_OK !=
-                GNUNET_BIO_write_int64 (wh, pos->time_creation.abs_value)) ||
-               (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;
-    }  
+    }
+
+    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);
+                         gettext_noop ("# hostlist URIs written to file"),
+                         counter, GNUNET_YES);
 
-  if ( GNUNET_OK != GNUNET_BIO_write_close ( wh ) )
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Error writing hostlist URIs to file `%s'\n"),
-                filename);
+                _("Error writing hostlist URIs to file `%s'\n"), filename);
   GNUNET_free (filename);
 }
 
@@ -1506,33 +1458,30 @@ static void save_hostlist_file ( int shutdown )
  */
 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_CORE_MessageCallback *msgh,
-                              int learn)
+                              struct GNUNET_STATISTICS_Handle *st,
+                              GNUNET_CORE_ConnectEventHandler *ch,
+                              GNUNET_CORE_DisconnectEventHandler *dh,
+                              GNUNET_CORE_MessageCallback *msgh, int learn)
 {
   char *filename;
   int result;
 
   if (0 != curl_global_init (CURL_GLOBAL_WIN32))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   transport = GNUNET_TRANSPORT_connect (c, NULL, NULL, NULL, NULL, NULL);
   if (NULL == transport)
-    {
-      curl_global_cleanup ();
-      return GNUNET_SYSERR;
-    }
+  {
+    curl_global_cleanup ();
+    return GNUNET_SYSERR;
+  }
   cfg = c;
   stats = st;
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "HOSTLIST",
-                                             "HTTP-PROXY", 
-                                             &proxy))
+                                             "HOSTLIST", "HTTP-PROXY", &proxy))
     proxy = NULL;
   stat_learning = learn;
   *ch = &handler_connect;
@@ -1543,51 +1492,49 @@ GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c,
   stat_testing_hostlist = GNUNET_NO;
   stat_testing_allowed = GNUNET_YES;
 
-  if ( GNUNET_YES == stat_learning )
+  if (GNUNET_YES == stat_learning)
   {
     *msgh = &handler_advertisement;
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Learning is enabled on this peer\n"));
+                _("Learning is enabled on this peer\n"));
     load_hostlist_file ();
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Hostlists will be saved to file again in  %llums\n"),
-              (unsigned long long) SAVING_INTERVALL.rel_value);
+                _("Hostlists will be saved to file again in  %llums\n"),
+                (unsigned long long) SAVING_INTERVALL.rel_value);
     ti_saving_task = GNUNET_SCHEDULER_add_delayed (SAVING_INTERVALL,
-                                                   &task_hostlist_saving,
-                                                   NULL);
+                                                   &task_hostlist_saving, NULL);
   }
   else
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Learning is not enabled on this peer\n"));
+                _("Learning is not enabled on this peer\n"));
     *msgh = NULL;
     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                            "HOSTLIST",
-                                                            "HOSTLISTFILE",
-                                                            &filename))
+                                                              "HOSTLIST",
+                                                              "HOSTLISTFILE",
+                                                              &filename))
     {
-    if ( GNUNET_YES == GNUNET_DISK_file_test (filename) )
+      if (GNUNET_YES == GNUNET_DISK_file_test (filename))
       {
         result = remove (filename);
         if (result == 0)
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                    _("Since learning is not enabled on this peer, hostlist file `%s' was removed\n"),
-                    filename);
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _
+                      ("Since learning is not enabled on this peer, hostlist file `%s' was removed\n"),
+                      filename);
         else
           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Hostlist file `%s' could not be removed\n"),
-                      filename);
+                      _("Hostlist file `%s' could not be removed\n"), filename);
       }
     }
-    GNUNET_free ( filename );
+    GNUNET_free (filename);
   }
   GNUNET_STATISTICS_get (stats,
-                         "hostlist",
-                         gettext_noop("# milliseconds between hostlist downloads"),
-                         GNUNET_TIME_UNIT_MINUTES,
-                         &primary_task,
-                         &process_stat,
-                         NULL);
+                         "hostlist",
+                         gettext_noop
+                         ("# milliseconds between hostlist downloads"),
+                         GNUNET_TIME_UNIT_MINUTES, &primary_task, &process_stat,
+                         NULL);
   return GNUNET_OK;
 }
 
@@ -1598,42 +1545,40 @@ GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c,
 void
 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 DEBUG_HOSTLIST_CLIENT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Hostlist client shutdown\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n");
 #endif
-  if ( GNUNET_YES == stat_learning )
-    save_hostlist_file ( GNUNET_YES );
+  if (GNUNET_YES == stat_learning)
+    save_hostlist_file (GNUNET_YES);
 
   if (ti_saving_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (ti_saving_task);
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_saving_task);
+  }
 
   if (ti_download_dispatcher_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (ti_download_dispatcher_task);
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_download_dispatcher_task);
+  }
   if (ti_testing_intervall_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (ti_testing_intervall_task);
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_testing_intervall_task);
+  }
   if (ti_download != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (ti_download);
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_download);
+  }
   if (ti_check_download != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (ti_check_download);
-      curl_global_cleanup ();
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ti_check_download);
+    curl_global_cleanup ();
+  }
   if (transport != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (transport);
-      transport = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_disconnect (transport);
+    transport = NULL;
+  }
   GNUNET_assert (NULL == transport);
   GNUNET_free_non_null (proxy);
   proxy = NULL;
diff --git a/src/hostlist/hostlist-client.h b/src/hostlist/hostlist-client.h
index b29b96a04..80ead64bb 100644
--- a/src/hostlist/hostlist-client.h
+++ b/src/hostlist/hostlist-client.h
@@ -91,18 +91,16 @@
  */
 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_CORE_MessageCallback *msgh,
-                              int learn);
+                              struct GNUNET_STATISTICS_Handle *st,
+                              GNUNET_CORE_ConnectEventHandler *ch,
+                              GNUNET_CORE_DisconnectEventHandler *dh,
+                              GNUNET_CORE_MessageCallback *msgh, int learn);
 
 
 /**
  * Stop downloading hostlists from hostlist servers as necessary.
  */
-void
-GNUNET_HOSTLIST_client_stop (void);
+void GNUNET_HOSTLIST_client_stop (void);
 
 
 #endif
diff --git a/src/hostlist/hostlist-server.c b/src/hostlist/hostlist-server.c
index c8e17f33a..e30b3c1e0 100644
--- a/src/hostlist/hostlist-server.c
+++ b/src/hostlist/hostlist-server.c
@@ -51,7 +51,7 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 /**
  * For keeping statistics.
- */ 
+ */
 static struct GNUNET_STATISTICS_Handle *stats;
 
 /**
@@ -107,7 +107,7 @@ static int advertising;
 /**
  * Buffer for the hostlist address
  */
-static char * hostlist_uri;
+static char *hostlist_uri;
 
 
 /**
@@ -125,16 +125,14 @@ finish_response (struct HostSet *results)
 #endif
   response = MHD_create_response_from_data (results->size,
                                             results->data, MHD_YES, MHD_NO);
-  if ( (daemon_handle_v4 == NULL) &&
-       (daemon_handle_v6 == NULL) )
+  if ((daemon_handle_v4 == NULL) && (daemon_handle_v6 == NULL))
   {
     MHD_destroy_response (response);
     response = NULL;
   }
   GNUNET_STATISTICS_set (stats,
-                         gettext_noop("bytes in hostlist"),
-                         results->size,
-                         GNUNET_YES);
+                         gettext_noop ("bytes in hostlist"),
+                         results->size, GNUNET_YES);
   GNUNET_free (results);
 }
 
@@ -151,21 +149,19 @@ finish_response (struct HostSet *results)
  */
 static int
 check_has_addr (void *cls,
-                const char *tname,
-                struct GNUNET_TIME_Absolute expiration,
-                const void *addr,
-                uint16_t addrlen)
+                const char *tname,
+                struct GNUNET_TIME_Absolute expiration,
+                const void *addr, uint16_t addrlen)
 {
   int *arg = cls;
 
   if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value == 0)
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop("expired addresses encountered"),
-                                1,
-                                GNUNET_YES);
-      return GNUNET_YES; /* ignore this address */
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("expired addresses encountered"),
+                              1, GNUNET_YES);
+    return GNUNET_YES;          /* ignore this address */
+  }
   *arg = GNUNET_YES;
   return GNUNET_SYSERR;
 }
@@ -177,74 +173,66 @@ check_has_addr (void *cls,
  */
 static void
 host_processor (void *cls,
-                const struct GNUNET_PeerIdentity * peer,
-                const struct GNUNET_HELLO_Message *hello,
-                const char *err_msg)
+                const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_HELLO_Message *hello, const char *err_msg)
 {
   struct HostSet *results = cls;
   size_t old;
   size_t s;
   int has_addr;
-  
+
   if (err_msg != NULL)
-    {
-      GNUNET_assert (NULL == peer);
-      pitr = NULL;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Error in communication with PEERINFO service: %s\n"), 
-                  err_msg);
-      return;
-    }
+  {
+    GNUNET_assert (NULL == peer);
+    pitr = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Error in communication with PEERINFO service: %s\n"),
+                err_msg);
+    return;
+  }
   if (peer == NULL)
-    {
-      pitr = NULL;
-      finish_response (results);
-      return;
-    }
+  {
+    pitr = NULL;
+    finish_response (results);
+    return;
+  }
   if (hello == NULL)
     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 = results->size;
-  s = GNUNET_HELLO_size(hello);
+  s = GNUNET_HELLO_size (hello);
 #if DEBUG_HOSTLIST_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
-              (unsigned int) s,
-              "HELLO",
-              GNUNET_i2s (peer));
+              "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
+              (unsigned int) s, "HELLO", GNUNET_i2s (peer));
 #endif
-  if ( (old + s >= GNUNET_MAX_MALLOC_CHECKED) || (old + s >= MAX_BYTES_PER_HOSTLISTS) )
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop("bytes not included in hostlist (size limit)"),
-                                s,
-                                GNUNET_NO);
-      return; /* too large, skip! */
-    }
+  if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) ||
+      (old + s >= MAX_BYTES_PER_HOSTLISTS))
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("bytes not included in hostlist (size limit)"),
+                              s, GNUNET_NO);
+    return;                     /* too large, skip! */
+  }
 #if DEBUG_HOSTLIST_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Adding peer `%s' to hostlist (%u bytes)\n",
-              GNUNET_i2s (peer),
-              (unsigned int) s);
+              "Adding peer `%s' to hostlist (%u bytes)\n",
+              GNUNET_i2s (peer), (unsigned int) s);
 #endif
-  GNUNET_array_grow (results->data,
-                     results->size,
-                     old + s);
+  GNUNET_array_grow (results->data, results->size, old + s);
   memcpy (&results->data[old], hello, s);
 }
 
@@ -258,13 +246,13 @@ accept_policy_callback (void *cls,
                         const struct sockaddr *addr, socklen_t addrlen)
 {
   if (NULL == response)
-    {
+  {
 #if DEBUG_HOSTLIST_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received request for hostlist, but I am not yet ready; rejecting!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received request for hostlist, but I am not yet ready; rejecting!\n");
 #endif
-      return MHD_NO;
-    }
+    return MHD_NO;
+  }
   return MHD_YES;               /* accept all */
 }
 
@@ -279,58 +267,54 @@ access_handler_callback (void *cls,
                          const char *method,
                          const char *version,
                          const char *upload_data,
-                         size_t*upload_data_size, void **con_cls)
+                         size_t * upload_data_size, void **con_cls)
 {
   static int dummy;
-  
+
   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;
-    }
+  {
+    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;
+  {
+    (*con_cls) = &dummy;
 #if DEBUG_HOSTLIST_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Sending 100 CONTINUE reply\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Sending 100 CONTINUE reply\n"));
 #endif
-      return MHD_YES;           /* send 100 continue */
-    }
+    return MHD_YES;             /* send 100 continue */
+  }
   if (*upload_data_size != 0)
-    {
-      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 (response == NULL)
-    {
-      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_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);
+                            gettext_noop ("hostlist requests processed"),
+                            1, GNUNET_YES);
   return MHD_queue_response (connection, MHD_HTTP_OK, response);
 }
 
@@ -342,41 +326,38 @@ access_handler_callback (void *cls,
  * @param buf   buffer to copy message to
  */
 static size_t
-adv_transmit_ready ( void *cls, size_t size, void *buf)
+adv_transmit_ready (void *cls, size_t size, void *buf)
 {
   static uint64_t hostlist_adv_count;
 
   size_t transmission_size;
-  size_t uri_size; /* Including \0 termination! */
+  size_t uri_size;              /* Including \0 termination! */
   struct GNUNET_MessageHeader header;
   char *cbuf;
 
   if (buf == NULL)
-    {
-      GNUNET_log ( GNUNET_ERROR_TYPE_DEBUG, 
-                   "Transmission failed, buffer invalid!\n" );
-      return 0;
-    }
-  uri_size = strlen ( hostlist_uri ) + 1;
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission failed, buffer invalid!\n");
+    return 0;
+  }
+  uri_size = strlen (hostlist_uri) + 1;
   transmission_size = sizeof (struct GNUNET_MessageHeader) + uri_size;
   header.type = htons (GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
   header.size = htons (transmission_size);
   GNUNET_assert (size >= transmission_size);
   memcpy (buf, &header, sizeof (struct GNUNET_MessageHeader));
-  cbuf = buf;  
-  memcpy (&cbuf[sizeof (struct GNUNET_MessageHeader)],
-          hostlist_uri, uri_size);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Sent advertisement message: Copied %u bytes into buffer!\n", 
-              (unsigned int) transmission_size);
+  cbuf = buf;
+  memcpy (&cbuf[sizeof (struct GNUNET_MessageHeader)], hostlist_uri, uri_size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sent advertisement message: Copied %u bytes into buffer!\n",
+              (unsigned int) transmission_size);
   hostlist_adv_count++;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              " # Sent advertisement message: %u\n",
-              hostlist_adv_count);
+              " # Sent advertisement message: %u\n", hostlist_adv_count);
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop("# hostlist advertisements send"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# hostlist advertisements send"),
+                            1, GNUNET_NO);
   return transmission_size;
 }
 
@@ -391,41 +372,42 @@ adv_transmit_ready ( void *cls, size_t size, void *buf)
 static void
 connect_handler (void *cls,
                  const struct
-                 GNUNET_PeerIdentity * peer,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 GNUNET_PeerIdentity *peer,
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   size_t size;
 
-  if ( !advertising )
+  if (!advertising)
     return;
   if (hostlist_uri == NULL)
     return;
   size = strlen (hostlist_uri) + 1;
-  if (size + sizeof (struct GNUNET_MessageHeader) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if (size + sizeof (struct GNUNET_MessageHeader) >=
+      GNUNET_SERVER_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    return;
+  }
   size += sizeof (struct GNUNET_MessageHeader);
   if (NULL == core)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asked core to transmit advertisement message with a size of %u bytes to peer `%s'\n",
-              size,GNUNET_i2s(peer));
+              size, GNUNET_i2s (peer));
   if (NULL == GNUNET_CORE_notify_transmit_ready (core,
-                                                 GNUNET_YES,
-                                                 0,
-                                                 GNUNET_ADV_TIMEOUT,
-                                                 peer,
-                                                 size,
-                                                 &adv_transmit_ready, NULL))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Advertisement message could not be queued by core\n"));
-    }
+                                                 GNUNET_YES,
+                                                 0,
+                                                 GNUNET_ADV_TIMEOUT,
+                                                 peer,
+                                                 size,
+                                                 &adv_transmit_ready, NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Advertisement message could not be queued by core\n"));
+  }
 }
 
 
@@ -436,9 +418,7 @@ connect_handler (void *cls,
  * @param peer peer identity this notification is about
  */
 static void
-disconnect_handler (void *cls,
-                    const struct
-                    GNUNET_PeerIdentity * peer)
+disconnect_handler (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   /* nothing to do */
 }
@@ -455,27 +435,26 @@ disconnect_handler (void *cls,
 static void
 process_notify (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_HELLO_Message *hello,
-                const char *err_msg)
+                const struct GNUNET_HELLO_Message *hello, const char *err_msg)
 {
   struct HostSet *results;
+
 #if DEBUG_HOSTLIST_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-            "Peerinfo is notifying us to rebuild our hostlist\n");
+              "Peerinfo is notifying us to rebuild our hostlist\n");
 #endif
   if (err_msg != NULL)
   {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      _("Error in communication with PEERINFO service\n"));
-        /* return; */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Error in communication with PEERINFO service\n"));
+    /* return; */
   }
-  results = GNUNET_malloc(sizeof(struct HostSet));
+  results = GNUNET_malloc (sizeof (struct HostSet));
   GNUNET_assert (peerinfo != NULL);
   pitr = GNUNET_PEERINFO_iterate (peerinfo,
                                   NULL,
                                   GNUNET_TIME_UNIT_MINUTES,
-                                  &host_processor,
-                                  results);
+                                  &host_processor, results);
 }
 
 /**
@@ -491,8 +470,7 @@ prepare_daemon (struct MHD_Daemon *daemon_handle);
  * and schedule the next run.
  */
 static void
-run_daemon (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+run_daemon (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct MHD_Daemon *daemon_handle = cls;
 
@@ -502,7 +480,7 @@ run_daemon (void *cls,
     hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    return;    
+    return;
   GNUNET_assert (MHD_YES == MHD_run (daemon_handle));
   if (daemon_handle == daemon_handle_v4)
     hostlist_task_v4 = prepare_daemon (daemon_handle);
@@ -529,20 +507,15 @@ prepare_daemon (struct MHD_Daemon *daemon_handle)
   unsigned long long timeout;
   int haveto;
   struct GNUNET_TIME_Relative tv;
-  
-  FD_ZERO(&rs);
-  FD_ZERO(&ws);
-  FD_ZERO(&es);
+
+  FD_ZERO (&rs);
+  FD_ZERO (&ws);
+  FD_ZERO (&es);
   wrs = GNUNET_NETWORK_fdset_create ();
   wes = GNUNET_NETWORK_fdset_create ();
   wws = GNUNET_NETWORK_fdset_create ();
   max = -1;
-  GNUNET_assert (MHD_YES ==
-                 MHD_get_fdset (daemon_handle,
-                                &rs,
-                                &ws,
-                                &es,
-                                &max));
+  GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max));
   haveto = MHD_get_timeout (daemon_handle, &timeout);
   if (haveto == MHD_YES)
     tv.rel_value = (uint64_t) timeout;
@@ -552,12 +525,8 @@ prepare_daemon (struct MHD_Daemon *daemon_handle)
   GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
   GNUNET_NETWORK_fdset_copy_native (wes, &es, max + 1);
   ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                     GNUNET_SCHEDULER_NO_TASK,
-                                     tv,
-                                     wrs,
-                                     wws,
-                                     &run_daemon,
-                                     daemon_handle);
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     tv, wrs, wws, &run_daemon, daemon_handle);
   GNUNET_NETWORK_fdset_destroy (wrs);
   GNUNET_NETWORK_fdset_destroy (wws);
   GNUNET_NETWORK_fdset_destroy (wes);
@@ -573,9 +542,9 @@ prepare_daemon (struct MHD_Daemon *daemon_handle)
  */
 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,
+                              struct GNUNET_STATISTICS_Handle *st,
+                              struct GNUNET_CORE_Handle *co,
+                              GNUNET_CORE_ConnectEventHandler *server_ch,
                               GNUNET_CORE_DisconnectEventHandler *server_dh,
                               int advertise)
 {
@@ -584,102 +553,100 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
   size_t size;
 
   advertising = advertise;
-  if  ( !advertising )
+  if (!advertising)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Advertising not enabled on this hostlist server\n");
+                "Advertising not enabled on this hostlist server\n");
   else
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Advertising enabled on this hostlist server\n");
+                "Advertising enabled on this hostlist server\n");
   cfg = c;
   stats = st;
   peerinfo = GNUNET_PEERINFO_connect (cfg);
   if (peerinfo == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not access PEERINFO service.  Exiting.\n"));     
-      return GNUNET_SYSERR;
-    }
+  {
+    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))
+                                                          "HOSTLIST",
+                                                          "HTTPPORT", &port))
     return GNUNET_SYSERR;
-  if ( (port == 0) ||
-       (port > UINT16_MAX) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Invalid port number %llu.  Exiting.\n"),
-                  port);            
-      return GNUNET_SYSERR;
-    }
+  if ((port == 0) || (port > UINT16_MAX))
+  {
+    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))
+  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);
+              _("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);
     }
-  daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 
+    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);
+  }
+  daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6
 #if DEBUG_HOSTLIST_SERVER
-                                       | MHD_USE_DEBUG
+                                       | MHD_USE_DEBUG
 #endif
-                                       ,
-                                       (unsigned short) port,
-                                       &accept_policy_callback,
-                                       NULL,
-                                       &access_handler_callback,
-                                       NULL,
-                                       MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 16,
-                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1,
-                                       MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
-                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (16 * 1024),
-                                       MHD_OPTION_END);
+                                       ,
+                                       (unsigned short) port,
+                                       &accept_policy_callback,
+                                       NULL,
+                                       &access_handler_callback,
+                                       NULL,
+                                       MHD_OPTION_CONNECTION_LIMIT,
+                                       (unsigned int) 16,
+                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
+                                       (unsigned int) 1,
+                                       MHD_OPTION_CONNECTION_TIMEOUT,
+                                       (unsigned int) 16,
+                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                                       (size_t) (16 * 1024), MHD_OPTION_END);
   daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG
 #if DEBUG_HOSTLIST_SERVER
-                                       | MHD_USE_DEBUG
+                                       | MHD_USE_DEBUG
 #endif
-                                       ,
-                                       (unsigned short) port,
-                                       &accept_policy_callback,
-                                       NULL,
-                                       &access_handler_callback,
-                                       NULL,
-                                       MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 16,
-                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1,
-                                       MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
-                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (16 * 1024),
-                                       MHD_OPTION_END);
-
-  if ( (daemon_handle_v6 == NULL) &&
-       (daemon_handle_v4 == NULL) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not start hostlist HTTP server on port %u\n"),
-                  (unsigned short) port);
-      return GNUNET_SYSERR;    
-    }
+                                       ,
+                                       (unsigned short) port,
+                                       &accept_policy_callback,
+                                       NULL,
+                                       &access_handler_callback,
+                                       NULL,
+                                       MHD_OPTION_CONNECTION_LIMIT,
+                                       (unsigned int) 16,
+                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
+                                       (unsigned int) 1,
+                                       MHD_OPTION_CONNECTION_TIMEOUT,
+                                       (unsigned int) 16,
+                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                                       (size_t) (16 * 1024), MHD_OPTION_END);
+
+  if ((daemon_handle_v6 == NULL) && (daemon_handle_v4 == NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not start hostlist HTTP server on port %u\n"),
+                (unsigned short) port);
+    return GNUNET_SYSERR;
+  }
 
   core = co;
 
@@ -691,7 +658,7 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
   if (daemon_handle_v6 != NULL)
     hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
 
-  notify = GNUNET_PEERINFO_notify ( cfg, process_notify, NULL);
+  notify = GNUNET_PEERINFO_notify (cfg, process_notify, NULL);
 
   return GNUNET_OK;
 }
@@ -703,49 +670,48 @@ void
 GNUNET_HOSTLIST_server_stop ()
 {
 #if DEBUG_HOSTLIST_SERVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Hostlist server shutdown\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
 #endif
   if (NULL != notify)
-    {
-      GNUNET_PEERINFO_notify_cancel (notify);
-      notify = NULL;
-    }
+  {
+    GNUNET_PEERINFO_notify_cancel (notify);
+    notify = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v6)
-    {
-      GNUNET_SCHEDULER_cancel (hostlist_task_v6);
-      hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (hostlist_task_v6);
+    hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v4)
-    {
-      GNUNET_SCHEDULER_cancel (hostlist_task_v4);
-      hostlist_task_v4 = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (hostlist_task_v4);
+    hostlist_task_v4 = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (pitr != NULL)
-    {
-      GNUNET_PEERINFO_iterate_cancel (pitr);
-      pitr = NULL;
-    }
+  {
+    GNUNET_PEERINFO_iterate_cancel (pitr);
+    pitr = 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 (response != NULL)
-    {
-      MHD_destroy_response (response);
-      response = NULL;
-    }
+  {
+    MHD_destroy_response (response);
+    response = NULL;
+  }
   if (peerinfo != NULL)
-    {
-      GNUNET_PEERINFO_disconnect (peerinfo);
-      peerinfo = NULL;
-    }
+  {
+    GNUNET_PEERINFO_disconnect (peerinfo);
+    peerinfo = NULL;
+  }
   cfg = NULL;
   stats = NULL;
   core = NULL;
diff --git a/src/hostlist/hostlist-server.h b/src/hostlist/hostlist-server.h
index 98ce2179b..7b7e37a4d 100644
--- a/src/hostlist/hostlist-server.h
+++ b/src/hostlist/hostlist-server.h
@@ -40,18 +40,17 @@
  */
 int
 GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
-                              struct GNUNET_STATISTICS_Handle *st,
-                              struct GNUNET_CORE_Handle *core,
+                              struct GNUNET_STATISTICS_Handle *st,
+                              struct GNUNET_CORE_Handle *core,
                               GNUNET_CORE_ConnectEventHandler *server_ch,
-                              GNUNET_CORE_DisconnectEventHandler *server_dh,
-                              int advertise);
+                              GNUNET_CORE_DisconnectEventHandler *server_dh,
+                              int advertise);
 
 
 /**
  * Stop server offering our hostlist.
  */
-void
-GNUNET_HOSTLIST_server_stop (void);
+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 7e42dda59..5cca8becd 100644
--- a/src/hostlist/test_gnunet_daemon_hostlist.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist.c
@@ -40,7 +40,7 @@
 static int ok;
 
 static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
-    
+
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -60,15 +60,15 @@ static void
 clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (p1.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (p1.th);
-      p1.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_disconnect (p1.th);
+    p1.th = NULL;
+  }
   if (p2.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (p2.th);
-      p2.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_disconnect (p2.th);
+    p2.th = NULL;
+  }
   GNUNET_SCHEDULER_shutdown ();
 }
 
@@ -80,7 +80,7 @@ timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Timeout trying to connect peers, test failed.\n");
+              "Timeout trying to connect peers, test failed.\n");
   clean_up (NULL, tc);
 }
 
@@ -96,32 +96,31 @@ timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 static void
 notify_connect (void *cls,
-                const struct GNUNET_PeerIdentity * peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
+                const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                uint32_t ats_count)
 {
   if (peer == NULL)
     return;
-  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 (timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (timeout_task);
-      timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_SCHEDULER_add_now (&clean_up, 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_get_hello_cancel (p->th, &process_hello, p);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received HELLO, starting hostlist service.\n");
+              "Received HELLO, starting hostlist service.\n");
 }
 
 
@@ -131,35 +130,34 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL,
-                                    &notify_connect, NULL);
+                                    &notify_connect, NULL);
   GNUNET_assert (p->th != NULL);
   GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
 }
 
 
 static void
-waitpid_task (void *cls, 
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+waitpid_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PeerContext *p = cls;
 
-#if START_ARM 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Killing ARM process.\n");
+#if START_ARM
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n");
   if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
+  if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
     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));
+              "ARM process %u stopped\n",
+              GNUNET_OS_process_get_pid (p->arm_proc));
   GNUNET_OS_process_close (p->arm_proc);
   p->arm_proc = NULL;
 #endif
@@ -170,10 +168,8 @@ waitpid_task (void *cls,
 static void
 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);
 }
 
 
@@ -191,17 +187,13 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile, 
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   ok++;
-  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &timeout_error,
-                                               NULL);
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+                                &shutdown_task, NULL);
   setup_peer (&p1, "test_gnunet_daemon_hostlist_peer1.conf");
   setup_peer (&p2, "test_gnunet_daemon_hostlist_peer2.conf");
 }
@@ -223,7 +215,7 @@ check ()
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
                       argv, "test-gnunet-daemon-hostlist",
-                      "nohelp", options, &run, &ok);
+                      "nohelp", options, &run, &ok);
   return ok;
 }
 
@@ -231,7 +223,7 @@ check ()
 int
 main (int argc, char *argv[])
 {
-  
+
   int ret;
 
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
@@ -248,7 +240,7 @@ main (int argc, char *argv[])
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist");
-  return ret; 
+  return ret;
 }
 
 /* end of test_gnunet_daemon_hostlist.c */
diff --git a/src/hostlist/test_gnunet_daemon_hostlist_learning.c b/src/hostlist/test_gnunet_daemon_hostlist_learning.c
index f821a7320..7ecca8a85 100644
--- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.c
@@ -43,7 +43,7 @@
 
 #define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 
-    
+
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -66,7 +66,7 @@ static int learned_hostlist_saved;
 
 static int learned_hostlist_downloaded;
 
-static char * current_adv_uri;
+static char *current_adv_uri;
 
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
@@ -78,106 +78,99 @@ static struct PeerContext adv_peer;
 
 static struct PeerContext learn_peer;
 
-static struct GNUNET_STATISTICS_GetHandle * download_stats;
+static struct GNUNET_STATISTICS_GetHandle *download_stats;
 
-static struct GNUNET_STATISTICS_GetHandle * urisrecv_stat;
+static struct GNUNET_STATISTICS_GetHandle *urisrecv_stat;
 
-static struct GNUNET_STATISTICS_GetHandle * advsent_stat;
+static struct GNUNET_STATISTICS_GetHandle *advsent_stat;
 
 
-static void 
-shutdown_testcase()
+static void
+shutdown_testcase ()
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Shutdown testcase....\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n");
   if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (timeout_task);
-      timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   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 (check_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (check_task);
-      check_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (check_task);
+    check_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != current_adv_uri)
-    {
-      GNUNET_free (current_adv_uri);
-      current_adv_uri = NULL;
-    }
+  {
+    GNUNET_free (current_adv_uri);
+    current_adv_uri = NULL;
+  }
   if (adv_peer.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (adv_peer.th);
-      adv_peer.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_disconnect (adv_peer.th);
+    adv_peer.th = NULL;
+  }
   if (learn_peer.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (learn_peer.th);
-      learn_peer.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_disconnect (learn_peer.th);
+    learn_peer.th = NULL;
+  }
   if (adv_peer.core != NULL)
-    {
-      GNUNET_CORE_disconnect (adv_peer.core);
-      adv_peer.core = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (adv_peer.core);
+    adv_peer.core = NULL;
+  }
   if (learn_peer.core != NULL)
-    {
-      GNUNET_CORE_disconnect (learn_peer.core);
-      learn_peer.core = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (learn_peer.core);
+    learn_peer.core = NULL;
+  }
 #if START_ARM
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Killing hostlist server ARM process.\n");
   if (0 != GNUNET_OS_process_kill (adv_peer.arm_proc, SIGTERM))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                         "kill");
-  if (GNUNET_OS_process_wait(adv_peer.arm_proc) != GNUNET_OK)
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                         "waitpid");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OS_process_wait (adv_peer.arm_proc) != GNUNET_OK)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
   GNUNET_OS_process_close (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, SIGTERM))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, 
-                         "kill");
-  if (GNUNET_OS_process_wait(learn_peer.arm_proc) != GNUNET_OK)
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                         "waitpid");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OS_process_wait (learn_peer.arm_proc) != GNUNET_OK)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
   GNUNET_OS_process_close (learn_peer.arm_proc);
   learn_peer.arm_proc = NULL;
 #endif
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Shutdown complete....\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n");
 }
 
 /**
  * Timeout, give up.
  */
 static void
-timeout_error (void *cls, 
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               "Timeout while executing testcase, test failed.\n");
   timeout = GNUNET_YES;
-  shutdown_testcase();
+  shutdown_testcase ();
 }
 
 
@@ -190,21 +183,17 @@ process_downloads_done (void *cls, int success)
 
 static int
 process_downloads (void *cls,
-                   const char *subsystem,
-                   const char *name,
-                   uint64_t value,
-                   int is_persistent)
+                   const char *subsystem,
+                   const char *name, uint64_t value, int is_persistent)
 {
-  if ( (value >= 2) && 
-       (learned_hostlist_downloaded == GNUNET_NO) )
-    {
-      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) )
-        shutdown_testcase();
-    }
+  if ((value >= 2) && (learned_hostlist_downloaded == GNUNET_NO))
+  {
+    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))
+      shutdown_testcase ();
+  }
   return GNUNET_OK;
 }
 
@@ -218,22 +207,18 @@ process_uris_recv_done (void *cls, int success)
 
 static int
 process_uris_recv (void *cls,
-                   const char *subsystem,
-                   const char *name,
-                   uint64_t value,
-                   int is_persistent)
+                   const char *subsystem,
+                   const char *name, uint64_t value, int is_persistent)
 {
-  if ( ((struct PeerContext *) cls == &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) )
-        shutdown_testcase();
-    }
+  if (((struct PeerContext *) cls == &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))
+      shutdown_testcase ();
+  }
   return GNUNET_OK;
 }
 
@@ -247,20 +232,18 @@ process_adv_sent_done (void *cls, int success)
 
 static int
 process_adv_sent (void *cls,
-                  const char *subsystem,
-                  const char *name,
-                  uint64_t value,
-                  int is_persistent)
+                  const char *subsystem,
+                  const char *name, uint64_t value, int is_persistent)
 {
-  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) )
-        shutdown_testcase();
-    }
+  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))
+      shutdown_testcase ();
+  }
   return GNUNET_OK;
 }
 
@@ -269,8 +252,7 @@ process_adv_sent (void *cls,
  * Check the server statistics regularly
  */
 static void
-check_statistics (void *cls, 
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   char *stat;
 
@@ -278,105 +260,102 @@ check_statistics (void *cls,
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   GNUNET_asprintf (&stat,
-                   gettext_noop("# advertised URI `%s' downloaded"),
-                   current_adv_uri);
+                   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,
-                                              GNUNET_TIME_UNIT_MINUTES,
-                                              &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"),
-                                             GNUNET_TIME_UNIT_MINUTES,
-                                             &process_uris_recv_done,
-                                             &process_uris_recv,
-                                             &learn_peer);
-    }
+  {
+    if (NULL != download_stats)
+      GNUNET_STATISTICS_get_cancel (download_stats);
+    download_stats = GNUNET_STATISTICS_get (learn_peer.stats,
+                                            "hostlist",
+                                            stat,
+                                            GNUNET_TIME_UNIT_MINUTES,
+                                            &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"),
+                                           GNUNET_TIME_UNIT_MINUTES,
+                                           &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"),
-                                            GNUNET_TIME_UNIT_MINUTES,
-                                            &process_adv_sent_done,
-                                            &process_adv_sent,
-                                            NULL);
-    }
+  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"),
+                                          GNUNET_TIME_UNIT_MINUTES,
+                                          &process_adv_sent_done,
+                                          &process_adv_sent, NULL);
+  }
   check_task = GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL,
-                                             &check_statistics,
-                                             NULL);
+                                             &check_statistics, NULL);
 }
 
 
 /**
  * Core handler for p2p hostlist advertisements
  */
-static int 
+static int
 ad_arrive_handler (void *cls,
-                   const struct GNUNET_PeerIdentity * peer,
-                   const struct GNUNET_MessageHeader * message,
-                   const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                   const struct GNUNET_PeerIdentity *peer,
+                   const struct GNUNET_MessageHeader *message,
+                   const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   char *hostname;
   char *expected_uri;
   unsigned long long port;
-  const struct GNUNET_MessageHeader * incoming;
+  const struct GNUNET_MessageHeader *incoming;
   const char *end;
 
   if (-1 == 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_SYSERR;
-    }
-
-  if ( GNUNET_SYSERR  == GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg,
-                                                                "HOSTLIST",
-                                                                "EXTERNAL_DNS_NAME",
-                                                                &hostname))
+                                                   "HTTPPORT", &port))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not read advertising server's configuration\n");
+    return GNUNET_SYSERR;
+  }
+
+  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);   
+                   "http://%s:%u/",
+                   hostname != NULL ? hostname : "localhost",
+                   (unsigned int) port);
   incoming = (const struct GNUNET_MessageHeader *) message;
-  end = (const char*) &incoming[1];
-  if ('\0' != end[ntohs(message->size) - sizeof (struct GNUNET_MessageHeader) - 1])
-    {
-      GNUNET_break (0);
-      GNUNET_free (expected_uri);
-      GNUNET_free_non_null (hostname);
-      return GNUNET_SYSERR;
-    }
+  end = (const char *) &incoming[1];
+  if ('\0' !=
+      end[ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - 1])
+  {
+    GNUNET_break (0);
+    GNUNET_free (expected_uri);
+    GNUNET_free_non_null (hostname);
+    return GNUNET_SYSERR;
+  }
   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;
-    }
+  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 recieved URI `%s' differ\n",
-                expected_uri,
-                current_adv_uri);
+                expected_uri, current_adv_uri);
   GNUNET_free (expected_uri);
   GNUNET_free_non_null (hostname);
   return GNUNET_OK;
@@ -387,83 +366,79 @@ ad_arrive_handler (void *cls,
  * List of handlers if we are learning.
  */
 static struct GNUNET_CORE_MessageHandler learn_handlers[] = {
-  { &ad_arrive_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
-  { NULL, 0, 0 }
+  {&ad_arrive_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
+  {NULL, 0, 0}
 };
 
 
 static void
-setup_learn_peer (struct PeerContext *p, 
-                  const char *cfgname)
+setup_learn_peer (struct PeerContext *p, const char *cfgname)
 {
-  char * filename;
+  char *filename;
   unsigned int result;
 
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
   if (GNUNET_OK == 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);
     }
+    GNUNET_free (filename);
+  }
   p->core = GNUNET_CORE_connect (p->cfg,
-                                 1,
-                                 NULL,
-                                 NULL,
-                                 NULL, NULL, NULL,
-                                 NULL, GNUNET_NO,
-                                 NULL, GNUNET_NO,
-                                 learn_handlers );
-  GNUNET_assert ( NULL != p->core );
+                                 1,
+                                 NULL,
+                                 NULL,
+                                 NULL, NULL, NULL,
+                                 NULL, GNUNET_NO,
+                                 NULL, GNUNET_NO, learn_handlers);
+  GNUNET_assert (NULL != p->core);
   p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
-  GNUNET_assert ( NULL != p->stats );
+  GNUNET_assert (NULL != p->stats);
 }
 
 
 static void
-setup_adv_peer (struct PeerContext *p, 
-                const char *cfgname)
+setup_adv_peer (struct PeerContext *p, const char *cfgname)
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
   p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
-  GNUNET_assert ( NULL != p->stats );
+  GNUNET_assert (NULL != p->stats);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile, 
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   timeout = GNUNET_NO;
-  adv_sent =GNUNET_NO;
+  adv_sent = GNUNET_NO;
 
   adv_arrived = 0;
   learned_hostlist_saved = GNUNET_NO;
@@ -473,13 +448,10 @@ run (void *cls,
 
   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);
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL);
 
   check_task = GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL,
-                                &check_statistics,
-                                NULL);
+                                             &check_statistics, NULL);
 }
 
 
@@ -487,7 +459,8 @@ static int
 check ()
 {
   unsigned int failed;
-  char *const argv[] = { 
+
+  char *const argv[] = {
     "test-gnunet-daemon-hostlist-learning",
     "-c", "learning_data.conf",
 #if VERBOSE
@@ -501,39 +474,37 @@ check ()
 
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
                       argv, "test-gnunet-daemon-hostlist-learning",
-                      "nohelp", options,
-                      &run, NULL);
+                      "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;
-    }
-  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,
+                "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;
+  }
   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;
@@ -542,7 +513,7 @@ check ()
 
 int
 main (int argc, char *argv[])
-{ 
+{
   int ret;
 
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
@@ -565,12 +536,12 @@ main (int argc, char *argv[])
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
   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");
-    }
-  return ret; 
+  {
+    if (0 == UNLINK ("hostlists_learn_peer.file"))
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Hostlist file hostlists_learn_peer.file was removed\n");
+  }
+  return ret;
 }
 
 /* end of test_gnunet_daemon_hostlist.c */
diff --git a/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c b/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c
index 7b6c858d4..d1227da4c 100644
--- a/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist_reconnect.c
@@ -41,7 +41,7 @@
 static int ok;
 
 static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
-    
+
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -61,15 +61,15 @@ static void
 clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (p1.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (p1.th);
-      p1.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_disconnect (p1.th);
+    p1.th = NULL;
+  }
   if (p2.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (p2.th);
-      p2.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_disconnect (p2.th);
+    p2.th = NULL;
+  }
   GNUNET_SCHEDULER_shutdown ();
 }
 
@@ -81,7 +81,7 @@ timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Timeout trying to connect peers, test failed.\n");
+              "Timeout trying to connect peers, test failed.\n");
   clean_up (NULL, tc);
 }
 
@@ -97,35 +97,34 @@ timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 static void
 notify_connect (void *cls,
-                const struct GNUNET_PeerIdentity * peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
+                const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                uint32_t ats_count)
 {
   if (peer == NULL)
     return;
 #if VERBOSE
   fprintf (stderr, "Peer %s connected\n", GNUNET_i2s (peer));
 #endif
-  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 (timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (timeout_task);
-      timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_SCHEDULER_add_now (&clean_up, 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_get_hello_cancel (p->th, &process_hello, p);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received HELLO, starting hostlist service.\n");
+              "Received HELLO, starting hostlist service.\n");
 }
 
 
@@ -135,35 +134,34 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL,
-                                    &notify_connect, NULL);
+                                    &notify_connect, NULL);
   GNUNET_assert (p->th != NULL);
   GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
 }
 
 
 static void
-waitpid_task (void *cls, 
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+waitpid_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PeerContext *p = cls;
 
-#if START_ARM 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Killing ARM process.\n");
+#if START_ARM
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n");
   if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
+  if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
     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));
+              "ARM process %u stopped\n",
+              GNUNET_OS_process_get_pid (p->arm_proc));
   GNUNET_OS_process_close (p->arm_proc);
   p->arm_proc = NULL;
 #endif
@@ -174,10 +172,8 @@ waitpid_task (void *cls,
 static void
 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);
 }
 
 
@@ -195,17 +191,13 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile, 
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   ok++;
-  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &timeout_error,
-                                               NULL);
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+                                &shutdown_task, NULL);
   setup_peer (&p1, "test_gnunet_daemon_hostlist_peer1.conf");
   setup_peer (&p2, "test_gnunet_daemon_hostlist_peer2.conf");
 }
@@ -227,7 +219,7 @@ check ()
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
                       argv, "test-gnunet-daemon-hostlist",
-                      "nohelp", options, &run, &ok);
+                      "nohelp", options, &run, &ok);
   return ok;
 }
 
@@ -235,7 +227,7 @@ check ()
 int
 main (int argc, char *argv[])
 {
-  
+
   int ret;
 
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
@@ -250,16 +242,16 @@ main (int argc, char *argv[])
                     NULL);
   ret = check ();
   if (ret == 0)
-    {
-      fprintf (stderr, ".");
-      /* now do it again */
-      ret = check ();
-      fprintf (stderr, ".\n");
-    }
+  {
+    fprintf (stderr, ".");
+    /* now do it again */
+    ret = check ();
+    fprintf (stderr, ".\n");
+  }
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-3");
-  return ret; 
+  return ret;
 }
 
 /* end of test_gnunet_daemon_hostlist_reconnect.c */