5 files changed, 464 insertions, 551 deletions

diff --git a/src/peerinfo/gnunet-service-peerinfo.c b/src/peerinfo/gnunet-service-peerinfo.c
index d5d153b65..160993649 100644
--- a/src/peerinfo/gnunet-service-peerinfo.c
+++ b/src/peerinfo/gnunet-service-peerinfo.c
@@ -130,13 +130,13 @@ discard_expired (void *cls,
                  const void *addr, uint16_t addrlen)
 {
   const struct GNUNET_TIME_Absolute *now = cls;
+
   if (now->abs_value > expiration.abs_value)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Removing expired address of transport `%s'\n"),
-                  tname);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("Removing expired address of transport `%s'\n"), tname);
+    return GNUNET_NO;
+  }
   return GNUNET_OK;
 }
 
@@ -153,8 +153,7 @@ get_host_filename (const struct GNUNET_PeerIdentity *id)
   char *fn;
 
   GNUNET_CRYPTO_hash_to_enc (&id->hashPubKey, &fil);
-  GNUNET_asprintf (&fn,
-                   "%s%s%s", networkIdDirectory, DIR_SEPARATOR_STR, &fil);
+  GNUNET_asprintf (&fn, "%s%s%s", networkIdDirectory, DIR_SEPARATOR_STR, &fil);
   return fn;
 }
 
@@ -172,8 +171,7 @@ notify_all (struct HostEntry *entry)
 
   msg = make_info_message (entry);
   GNUNET_SERVER_notification_context_broadcast (notify_list,
-                                                &msg->header,
-                                                GNUNET_NO);
+                                                &msg->header, GNUNET_NO);
   GNUNET_free (msg);
 }
 
@@ -194,46 +192,41 @@ add_host_to_known_hosts (const struct GNUNET_PeerIdentity *identity)
   struct GNUNET_TIME_Absolute now;
   char *fn;
 
-  entry = GNUNET_CONTAINER_multihashmap_get (hostmap,
-                                             &identity->hashPubKey);
+  entry = GNUNET_CONTAINER_multihashmap_get (hostmap, &identity->hashPubKey);
   if (entry != NULL)
     return;
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# peers known"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# peers known"), 1, GNUNET_NO);
   entry = GNUNET_malloc (sizeof (struct HostEntry));
   entry->identity = *identity;
 
   fn = get_host_filename (identity);
   if (GNUNET_DISK_file_test (fn) == GNUNET_YES)
+  {
+    size = GNUNET_DISK_fn_read (fn, buffer, sizeof (buffer));
+    hello = (const struct GNUNET_HELLO_Message *) buffer;
+    if ((size < sizeof (struct GNUNET_MessageHeader)) ||
+        (size != ntohs ((((const struct GNUNET_MessageHeader *) hello)->size)))
+        || (size != GNUNET_HELLO_size (hello)))
     {
-      size = GNUNET_DISK_fn_read (fn, buffer, sizeof (buffer));
-      hello = (const struct GNUNET_HELLO_Message *) buffer;
-      if ( (size < sizeof (struct GNUNET_MessageHeader)) ||
-           (size != ntohs((((const struct GNUNET_MessageHeader*) hello)->size))) ||
-           (size != GNUNET_HELLO_size (hello)) )
-        {
-          GNUNET_break (0);
-          if (0 != UNLINK (fn))
-            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                      "unlink",
-                                      fn);
-        }
-      else
-        {
-          now = GNUNET_TIME_absolute_get ();
-          hello_clean = GNUNET_HELLO_iterate_addresses (hello,
-                                                        GNUNET_YES,
-                                                        &discard_expired, &now);
-          entry->hello = hello_clean;
-        }
+      GNUNET_break (0);
+      if (0 != UNLINK (fn))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
     }
+    else
+    {
+      now = GNUNET_TIME_absolute_get ();
+      hello_clean = GNUNET_HELLO_iterate_addresses (hello,
+                                                    GNUNET_YES,
+                                                    &discard_expired, &now);
+      entry->hello = hello_clean;
+    }
+  }
   GNUNET_free (fn);
   GNUNET_CONTAINER_multihashmap_put (hostmap,
-                                     &identity->hashPubKey,
-                                     entry,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+                                     &identity->hashPubKey,
+                                     entry,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
   notify_all (entry);
 }
 
@@ -257,8 +250,7 @@ remove_garbage (const char *fullname)
 
 
 static int
-hosts_directory_scan_callback (void *cls,
-                               const char *fullname)
+hosts_directory_scan_callback (void *cls, const char *fullname)
 {
   unsigned int *matched = cls;
   struct GNUNET_PeerIdentity identity;
@@ -267,24 +259,24 @@ hosts_directory_scan_callback (void *cls,
   if (GNUNET_DISK_file_test (fullname) != GNUNET_YES)
     return GNUNET_OK;           /* ignore non-files */
   if (strlen (fullname) < sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded))
-    {
-      remove_garbage (fullname);
-      return GNUNET_OK;
-    }
+  {
+    remove_garbage (fullname);
+    return GNUNET_OK;
+  }
   filename =
-    &fullname[strlen (fullname) -
-              sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) + 1];
+      &fullname[strlen (fullname) -
+                sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) + 1];
   if (filename[-1] != DIR_SEPARATOR)
-    {
-      remove_garbage (fullname);
-      return GNUNET_OK;
-    }
+  {
+    remove_garbage (fullname);
+    return GNUNET_OK;
+  }
   if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (filename,
                                                    &identity.hashPubKey))
-    {
-      remove_garbage (fullname);
-      return GNUNET_OK;
-    }
+  {
+    remove_garbage (fullname);
+    return GNUNET_OK;
+  }
   (*matched)++;
   add_host_to_known_hosts (&identity);
   return GNUNET_OK;
@@ -305,11 +297,11 @@ cron_scan_directory_data_hosts (void *cls,
     return;
   count = 0;
   if (GNUNET_SYSERR == GNUNET_DISK_directory_create (networkIdDirectory))
-    {
-      GNUNET_SCHEDULER_add_delayed (DATA_HOST_FREQ,
-                                    &cron_scan_directory_data_hosts, NULL);
-      return;
-    }
+  {
+    GNUNET_SCHEDULER_add_delayed (DATA_HOST_FREQ,
+                                  &cron_scan_directory_data_hosts, NULL);
+    return;
+  }
   GNUNET_DISK_directory_scan (networkIdDirectory,
                               &hosts_directory_scan_callback, &count);
   if ((0 == count) && (0 == (++retries & 31)))
@@ -337,42 +329,39 @@ bind_address (const struct GNUNET_PeerIdentity *peer,
   struct GNUNET_TIME_Absolute delta;
 
   add_host_to_known_hosts (peer);
-  host = GNUNET_CONTAINER_multihashmap_get (hostmap,
-                                            &peer->hashPubKey);
+  host = GNUNET_CONTAINER_multihashmap_get (hostmap, &peer->hashPubKey);
   GNUNET_assert (host != NULL);
   if (host->hello == NULL)
-    {
-      host->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
-      memcpy (host->hello, hello, GNUNET_HELLO_size (hello));
-    }
+  {
+    host->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
+    memcpy (host->hello, hello, GNUNET_HELLO_size (hello));
+  }
   else
+  {
+    mrg = GNUNET_HELLO_merge (host->hello, hello);
+    delta = GNUNET_HELLO_equals (mrg, host->hello, GNUNET_TIME_absolute_get ());
+    if (delta.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
     {
-      mrg = GNUNET_HELLO_merge (host->hello, hello);
-      delta = GNUNET_HELLO_equals (mrg,
-                                   host->hello,
-                                   GNUNET_TIME_absolute_get ());
-      if (delta.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
-        {
-          GNUNET_free (mrg);
-          return;
-        }
-      GNUNET_free (host->hello);
-      host->hello = mrg;
+      GNUNET_free (mrg);
+      return;
     }
+    GNUNET_free (host->hello);
+    host->hello = mrg;
+  }
   fn = get_host_filename (peer);
   if (GNUNET_OK == GNUNET_DISK_directory_create_for_file (fn))
-    {
-      if (GNUNET_SYSERR ==
-          GNUNET_DISK_fn_write (fn, 
-                                host->hello, 
-                                GNUNET_HELLO_size (host->hello),
-                                GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
-                                | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_OTHER_READ))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                  "write",
-                                  fn);
-        
-    }
+  {
+    if (GNUNET_SYSERR ==
+        GNUNET_DISK_fn_write (fn,
+                              host->hello,
+                              GNUNET_HELLO_size (host->hello),
+                              GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE |
+                              GNUNET_DISK_PERM_GROUP_READ |
+                              GNUNET_DISK_PERM_OTHER_READ))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
+
+  }
   GNUNET_free (fn);
   notify_all (host);
 }
@@ -388,9 +377,7 @@ bind_address (const struct GNUNET_PeerIdentity *peer,
  * @return GNUNET_YES (continue to iterate)
  */
 static int
-add_to_tc (void *cls,
-           const GNUNET_HashCode *key,
-           void *value)
+add_to_tc (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_SERVER_TransmitContext *tc = cls;
   struct HostEntry *pos = value;
@@ -401,19 +388,18 @@ add_to_tc (void *cls,
   hs = 0;
   im = (struct InfoMessage *) buf;
   if (pos->hello != NULL)
-    {
-      hs = GNUNET_HELLO_size (pos->hello);
-      GNUNET_assert (hs <
-                     GNUNET_SERVER_MAX_MESSAGE_SIZE -
-                     sizeof (struct InfoMessage));
-      memcpy (&im[1], pos->hello, hs);
-    }
+  {
+    hs = GNUNET_HELLO_size (pos->hello);
+    GNUNET_assert (hs <
+                   GNUNET_SERVER_MAX_MESSAGE_SIZE -
+                   sizeof (struct InfoMessage));
+    memcpy (&im[1], pos->hello, hs);
+  }
   im->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_INFO);
   im->header.size = htons (sizeof (struct InfoMessage) + hs);
   im->reserved = htonl (0);
   im->peer = pos->identity;
-  GNUNET_SERVER_transmit_context_append_message (tc,
-                                                 &im->header);
+  GNUNET_SERVER_transmit_context_append_message (tc, &im->header);
   return GNUNET_YES;
 }
 
@@ -432,31 +418,33 @@ discard_hosts_helper (void *cls, const char *fn)
 
   size = GNUNET_DISK_fn_read (fn, buffer, sizeof (buffer));
   if (size < sizeof (struct GNUNET_MessageHeader))
-    {
-      if (0 != UNLINK (fn))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
-                                  GNUNET_ERROR_TYPE_BULK, "unlink", fn);
-      return GNUNET_OK;
-    }
+  {
+    if (0 != UNLINK (fn))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
+                                GNUNET_ERROR_TYPE_BULK, "unlink", fn);
+    return GNUNET_OK;
+  }
   hello = (const struct GNUNET_HELLO_Message *) buffer;
   new_hello = GNUNET_HELLO_iterate_addresses (hello,
                                               GNUNET_YES,
                                               &discard_expired, now);
   if (new_hello != NULL)
-    {
-      GNUNET_DISK_fn_write (fn, 
-                            new_hello,
-                            GNUNET_HELLO_size (new_hello),
-                            GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
-                            | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_OTHER_READ);
-      GNUNET_free (new_hello);
-    }
+  {
+    GNUNET_DISK_fn_write (fn,
+                          new_hello,
+                          GNUNET_HELLO_size (new_hello),
+                          GNUNET_DISK_PERM_USER_READ |
+                          GNUNET_DISK_PERM_USER_WRITE |
+                          GNUNET_DISK_PERM_GROUP_READ |
+                          GNUNET_DISK_PERM_OTHER_READ);
+    GNUNET_free (new_hello);
+  }
   else
-    {
-      if (0 != UNLINK (fn))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
-                                  GNUNET_ERROR_TYPE_BULK, "unlink", fn);      
-    }
+  {
+    if (0 != UNLINK (fn))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
+                                GNUNET_ERROR_TYPE_BULK, "unlink", fn);
+  }
   return GNUNET_OK;
 }
 
@@ -465,16 +453,14 @@ discard_hosts_helper (void *cls, const char *fn)
  * Call this method periodically to scan data/hosts for new hosts.
  */
 static void
-cron_clean_data_hosts (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+cron_clean_data_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TIME_Absolute now;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   now = GNUNET_TIME_absolute_get ();
-  GNUNET_DISK_directory_scan (networkIdDirectory,
-                              &discard_hosts_helper, &now);
+  GNUNET_DISK_directory_scan (networkIdDirectory, &discard_hosts_helper, &now);
   GNUNET_SCHEDULER_add_delayed (DATA_HOST_CLEAN_FREQ,
                                 &cron_clean_data_hosts, NULL);
 }
@@ -489,24 +475,23 @@ cron_clean_data_hosts (void *cls,
  */
 static void
 handle_hello (void *cls,
-              struct GNUNET_SERVER_Client *client,
-              const struct GNUNET_MessageHeader *message)
+              struct GNUNET_SERVER_Client *client,
+              const struct GNUNET_MessageHeader *message)
 {
   const struct GNUNET_HELLO_Message *hello;
   struct GNUNET_PeerIdentity pid;
 
   hello = (const struct GNUNET_HELLO_Message *) message;
-  if (GNUNET_OK !=  GNUNET_HELLO_get_id (hello, &pid))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  if (GNUNET_OK != GNUNET_HELLO_get_id (hello, &pid))
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "`%s' message received for peer `%4s'\n",
-              "HELLO",
-              GNUNET_i2s (&pid));
+              "`%s' message received for peer `%4s'\n",
+              "HELLO", GNUNET_i2s (&pid));
 #endif
   bind_address (&pid, hello);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -532,17 +517,15 @@ handle_get (void *cls,
   GNUNET_break (0 == ntohl (lpm->reserved));
 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "`%s' message received for peer `%4s'\n",
-              "GET",
-              GNUNET_i2s (&lpm->peer));
+              "`%s' message received for peer `%4s'\n",
+              "GET", GNUNET_i2s (&lpm->peer));
 #endif
   tc = GNUNET_SERVER_transmit_context_create (client);
   GNUNET_CONTAINER_multihashmap_get_multiple (hostmap,
-                                              &lpm->peer.hashPubKey,
-                                              &add_to_tc,
-                                              tc);
+                                              &lpm->peer.hashPubKey,
+                                              &add_to_tc, tc);
   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
-                                              GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
+                                              GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
   GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
@@ -562,24 +545,18 @@ handle_get_all (void *cls,
   struct GNUNET_SERVER_TransmitContext *tc;
 
 #if DEBUG_PEERINFO
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "`%s' message received\n",
-              "GET_ALL");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' message received\n", "GET_ALL");
 #endif
   tc = GNUNET_SERVER_transmit_context_create (client);
-  GNUNET_CONTAINER_multihashmap_iterate (hostmap,
-                                         &add_to_tc,
-                                         tc);
+  GNUNET_CONTAINER_multihashmap_iterate (hostmap, &add_to_tc, tc);
   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
-                                              GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
+                                              GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
   GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
 static int
-do_notify_entry (void *cls,
-                 const GNUNET_HashCode *key,
-                 void *value)
+do_notify_entry (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_SERVER_Client *client = cls;
   struct HostEntry *he = value;
@@ -587,9 +564,7 @@ do_notify_entry (void *cls,
 
   msg = make_info_message (he);
   GNUNET_SERVER_notification_context_unicast (notify_list,
-                                              client,
-                                              &msg->header,
-                                              GNUNET_NO);
+                                              client, &msg->header, GNUNET_NO);
   GNUNET_free (msg);
   return GNUNET_YES;
 }
@@ -604,27 +579,20 @@ do_notify_entry (void *cls,
  */
 static void
 handle_notify (void *cls,
-               struct GNUNET_SERVER_Client *client,
-               const struct GNUNET_MessageHeader *message)
+               struct GNUNET_SERVER_Client *client,
+               const struct GNUNET_MessageHeader *message)
 {
 #if DEBUG_PEERINFO
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "`%s' message received\n",
-              "NOTIFY");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' message received\n", "NOTIFY");
 #endif
-  GNUNET_SERVER_notification_context_add (notify_list,
-                                          client);
-  GNUNET_CONTAINER_multihashmap_iterate (hostmap,
-                                         &do_notify_entry,
-                                         client);
+  GNUNET_SERVER_notification_context_add (notify_list, client);
+  GNUNET_CONTAINER_multihashmap_iterate (hostmap, &do_notify_entry, client);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 
 static int
-free_host_entry (void *cls,
-                 const GNUNET_HashCode *key,
-                 void *value)
+free_host_entry (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct HostEntry *he = value;
 
@@ -640,20 +608,17 @@ free_host_entry (void *cls,
  * @param tc scheduler task context, unused
  */
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_SERVER_notification_context_destroy (notify_list);
   notify_list = NULL;
-  GNUNET_CONTAINER_multihashmap_iterate (hostmap,
-                                         &free_host_entry,
-                                         NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (hostmap, &free_host_entry, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (hostmap);
   if (stats != NULL)
-    {
-      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }
 }
 
 
@@ -690,11 +655,11 @@ run (void *cls,
                                                           &networkIdDirectory));
   GNUNET_DISK_directory_create (networkIdDirectory);
   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                      &cron_scan_directory_data_hosts, NULL);
+                                      &cron_scan_directory_data_hosts, NULL);
   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                      &cron_clean_data_hosts, NULL);
+                                      &cron_clean_data_hosts, NULL);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task, NULL);
+                                &shutdown_task, NULL);
   GNUNET_SERVER_add_handlers (server, handlers);
 }
 
@@ -712,11 +677,10 @@ main (int argc, char *const *argv)
   int ret;
 
   ret = (GNUNET_OK ==
-         GNUNET_SERVICE_run (argc,
-                             argv,
-                              "peerinfo",
-                             GNUNET_SERVICE_OPTION_NONE,
-                             &run, NULL)) ? 0 : 1;
+         GNUNET_SERVICE_run (argc,
+                             argv,
+                             "peerinfo",
+                             GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
   GNUNET_free_non_null (networkIdDirectory);
   return ret;
 }
diff --git a/src/peerinfo/peerinfo_api.c b/src/peerinfo/peerinfo_api.c
index b6ccdfd07..444ae98e2 100644
--- a/src/peerinfo/peerinfo_api.c
+++ b/src/peerinfo/peerinfo_api.c
@@ -37,8 +37,7 @@
  * @param cls closure
  * @param success GNUNET_OK if transmission worked, GNUNET_SYSERR on error
  */
-typedef void (*TransmissionContinuation)(void *cls,
-                                         int success);
+typedef void (*TransmissionContinuation) (void *cls, int success);
 
 
 /**
@@ -50,7 +49,7 @@ struct TransmissionQueueEntry
    * This is a linked list.
    */
   struct TransmissionQueueEntry *next;
-  
+
   /**
    * This is a linked list.
    */
@@ -61,7 +60,7 @@ struct TransmissionQueueEntry
    * case we must consider sending the next entry immediately).
    */
   TransmissionContinuation cont;
-  
+
   /**
    * Closure for 'cont'.
    */
@@ -158,29 +157,27 @@ GNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h)
   struct TransmissionQueueEntry *tqe;
 
   while (NULL != (tqe = h->tq_head))
-    {     
-      GNUNET_CONTAINER_DLL_remove (h->tq_head,
-                                   h->tq_tail,
-                                   tqe);
-      if (tqe->cont != NULL)
-        tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
-      GNUNET_free (tqe);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (h->tq_head, h->tq_tail, tqe);
+    if (tqe->cont != NULL)
+      tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
+    GNUNET_free (tqe);
+  }
   if (h->th != NULL)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-      h->th = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
+    h->th = NULL;
+  }
   if (NULL != h->client)
-    {
-      GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
-      h->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
+    h->client = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != h->r_task)
-    {
-      GNUNET_SCHEDULER_cancel (h->r_task);
-      h->r_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->r_task);
+    h->r_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_free (h);
 }
 
@@ -191,8 +188,7 @@ GNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h)
  *
  * @param h handle to the service
  */
-static void
-trigger_transmit (struct GNUNET_PEERINFO_Handle *h);
+static void trigger_transmit (struct GNUNET_PEERINFO_Handle *h);
 
 
 /**
@@ -200,8 +196,7 @@ trigger_transmit (struct GNUNET_PEERINFO_Handle *h);
  *
  * @param h handle to the service
  */
-static void
-reconnect (struct GNUNET_PEERINFO_Handle *h);
+static void reconnect (struct GNUNET_PEERINFO_Handle *h);
 
 /**
  * Task scheduled to re-try connecting to the peerinfo service.
@@ -210,8 +205,7 @@ reconnect (struct GNUNET_PEERINFO_Handle *h);
  * @param ts scheduler context
  */
 static void
-reconnect_task (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_PEERINFO_Handle *h = cls;
 
@@ -229,28 +223,27 @@ static void
 reconnect (struct GNUNET_PEERINFO_Handle *h)
 {
   if (h->r_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (h->r_task);
-      h->r_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->r_task);
+    h->r_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != h->th)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-      h->th = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
+    h->th = NULL;
+  }
   if (NULL != h->client)
-    {
-      GNUNET_CLIENT_disconnect (h->client, GNUNET_SYSERR);
-      h->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (h->client, GNUNET_SYSERR);
+    h->client = NULL;
+  }
   h->client = GNUNET_CLIENT_connect ("peerinfo", h->cfg);
   if (NULL == h->client)
-    {
-      h->r_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                                &reconnect_task, 
-                                                h);
-      return;
-    }
+  {
+    h->r_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                              &reconnect_task, h);
+    return;
+  }
   trigger_transmit (h);
 }
 
@@ -275,31 +268,25 @@ do_transmit (void *cls, size_t size, void *buf)
   if (tqe == NULL)
     return 0;
   if (buf == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-                  _("Failed to transmit message to `%s' service.\n"),
-                  "PEERINFO");
-      GNUNET_CONTAINER_DLL_remove (h->tq_head,
-                                   h->tq_tail,
-                                   tqe);
-      reconnect (h);
-      if (tqe->cont != NULL)
-        tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
-      GNUNET_free (tqe);
-      return 0;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                _("Failed to transmit message to `%s' service.\n"), "PEERINFO");
+    GNUNET_CONTAINER_DLL_remove (h->tq_head, h->tq_tail, tqe);
+    reconnect (h);
+    if (tqe->cont != NULL)
+      tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
+    GNUNET_free (tqe);
+    return 0;
+  }
   ret = tqe->size;
   GNUNET_assert (size >= ret);
   memcpy (buf, &tqe[1], ret);
 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting request of size %u to `%s' service.\n",
-              ret, 
-              "PEERINFO");
+              "Transmitting request of size %u to `%s' service.\n",
+              ret, "PEERINFO");
 #endif
-   GNUNET_CONTAINER_DLL_remove (h->tq_head,
-                               h->tq_tail,
-                               tqe);
+  GNUNET_CONTAINER_DLL_remove (h->tq_head, h->tq_tail, tqe);
   if (tqe->cont != NULL)
     tqe->cont (tqe->cont_cls, GNUNET_OK);
   else
@@ -327,15 +314,15 @@ trigger_transmit (struct GNUNET_PEERINFO_Handle *h)
   if (h->in_receive == GNUNET_YES)
     return;
   if (NULL == h->client)
-    {
-      reconnect (h);
-      return;
-    }
+  {
+    reconnect (h);
+    return;
+  }
   h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
-                                               tqe->size,
-                                               GNUNET_TIME_absolute_get_remaining (tqe->timeout),
-                                               GNUNET_YES,
-                                               &do_transmit, h);  
+                                               tqe->size,
+                                               GNUNET_TIME_absolute_get_remaining
+                                               (tqe->timeout), GNUNET_YES,
+                                               &do_transmit, h);
 }
 
 
@@ -352,28 +339,24 @@ trigger_transmit (struct GNUNET_PEERINFO_Handle *h)
  */
 void
 GNUNET_PEERINFO_add_peer (struct GNUNET_PEERINFO_Handle *h,
-                          const struct GNUNET_HELLO_Message *hello)
+                          const struct GNUNET_HELLO_Message *hello)
 {
   uint16_t hs = GNUNET_HELLO_size (hello);
   struct TransmissionQueueEntry *tqe;
-  
+
 #if DEBUG_PEERINFO
   struct GNUNET_PeerIdentity peer;
+
   GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (hello, &peer));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding peer `%s' to PEERINFO database (%u bytes of `%s')\n",
-              GNUNET_i2s(&peer),
-              hs,
-              "HELLO");
+              "Adding peer `%s' to PEERINFO database (%u bytes of `%s')\n",
+              GNUNET_i2s (&peer), hs, "HELLO");
 #endif
   tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) + hs);
   tqe->size = hs;
   tqe->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   memcpy (&tqe[1], hello, hs);
-  GNUNET_CONTAINER_DLL_insert_after (h->tq_head,
-                                     h->tq_tail,
-                                     h->tq_tail,
-                                     tqe);
+  GNUNET_CONTAINER_DLL_insert_after (h->tq_head, h->tq_tail, h->tq_tail, tqe);
   trigger_transmit (h);
 }
 
@@ -428,8 +411,7 @@ struct GNUNET_PEERINFO_IteratorContext
  * @param msg message received, NULL on timeout or fatal error
  */
 static void
-peerinfo_handler (void *cls, 
-                  const struct GNUNET_MessageHeader *msg)
+peerinfo_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_PEERINFO_IteratorContext *ic = cls;
   const struct InfoMessage *im;
@@ -438,79 +420,76 @@ peerinfo_handler (void *cls,
 
   ic->h->in_receive = GNUNET_NO;
   if (msg == NULL)
-    {
-      reconnect (ic->h);
-      if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (ic->timeout_task);
-      if (ic->callback != NULL)
-        ic->callback (ic->callback_cls, NULL, NULL, 
-                      _("Failed to receive response from `PEERINFO' service."));
-      GNUNET_free (ic);
-      return;
-    }
+  {
+    reconnect (ic->h);
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL,
+                    _("Failed to receive response from `PEERINFO' service."));
+    GNUNET_free (ic);
+    return;
+  }
   if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END)
-    {
+  {
 #if DEBUG_PEERINFO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received end of list of peers from `%s' service\n",
-                  "PEERINFO");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received end of list of peers from `%s' service\n",
+                "PEERINFO");
 #endif
-      trigger_transmit (ic->h);
-      if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (ic->timeout_task);
-      if (ic->callback != NULL)
-        ic->callback (ic->callback_cls, NULL, NULL, NULL);
-      GNUNET_free (ic);
-      return;
-    }
+    trigger_transmit (ic->h);
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL, NULL);
+    GNUNET_free (ic);
+    return;
+  }
   ms = ntohs (msg->size);
   if ((ms < sizeof (struct InfoMessage)) ||
       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_PEERINFO_INFO))
+  {
+    GNUNET_break (0);
+    reconnect (ic->h);
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL,
+                    _("Received invalid message from `PEERINFO' service.\n"));
+    GNUNET_free (ic);
+    return;
+  }
+  im = (const struct InfoMessage *) msg;
+  GNUNET_break (0 == ntohl (im->reserved));
+  hello = NULL;
+  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
+  {
+    hello = (const struct GNUNET_HELLO_Message *) &im[1];
+    if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
     {
       GNUNET_break (0);
       reconnect (ic->h);
       if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (ic->timeout_task);
+        GNUNET_SCHEDULER_cancel (ic->timeout_task);
       if (ic->callback != NULL)
-        ic->callback (ic->callback_cls, NULL, NULL, 
-                      _("Received invalid message from `PEERINFO' service.\n"));
+        ic->callback (ic->callback_cls, NULL, NULL,
+                      _("Received invalid message from `PEERINFO' service.\n"));
       GNUNET_free (ic);
       return;
     }
-  im = (const struct InfoMessage *) msg;
-  GNUNET_break (0 == ntohl (im->reserved));
-  hello = NULL;
-  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
-    {
-      hello = (const struct GNUNET_HELLO_Message *) &im[1];
-      if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
-        {
-          GNUNET_break (0);
-          reconnect (ic->h);
-          if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-            GNUNET_SCHEDULER_cancel (ic->timeout_task);
-          if (ic->callback != NULL)
-            ic->callback (ic->callback_cls, NULL, NULL, 
-                          _("Received invalid message from `PEERINFO' service.\n"));
-          GNUNET_free (ic);
-          return;
-        }
-    }
+  }
 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received %u bytes of `%s' information about peer `%s' from `%s' service\n",
-              (hello == NULL) ? 0 : (unsigned int) GNUNET_HELLO_size (hello),
-              "HELLO",
-              GNUNET_i2s (&im->peer),
-              "PEERINFO");
+              "Received %u bytes of `%s' information about peer `%s' from `%s' service\n",
+              (hello == NULL) ? 0 : (unsigned int) GNUNET_HELLO_size (hello),
+              "HELLO", GNUNET_i2s (&im->peer), "PEERINFO");
 #endif
   ic->h->in_receive = GNUNET_YES;
   if (ic->callback != NULL)
     ic->callback (ic->callback_cls, &im->peer, hello, NULL);
   GNUNET_CLIENT_receive (ic->h->client,
                          &peerinfo_handler,
-                         ic,
-                         GNUNET_TIME_absolute_get_remaining (ic->timeout));
+                         ic, GNUNET_TIME_absolute_get_remaining (ic->timeout));
 }
 
 
@@ -522,37 +501,35 @@ peerinfo_handler (void *cls,
  * @param transmit_success GNUNET_OK if transmission worked
  */
 static void
-iterator_start_receive (void *cls,
-                        int transmit_success)
+iterator_start_receive (void *cls, int transmit_success)
 {
   struct GNUNET_PEERINFO_IteratorContext *ic = cls;
 
   if (GNUNET_OK != transmit_success)
+  {
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (ic->timeout_task);
-          ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      reconnect (ic->h);
-      if (ic->callback != NULL)
-        ic->callback (ic->callback_cls, NULL, NULL,
-                      _("Failed to transmit iteration request to `PEERINFO' service\n"));
-      GNUNET_free (ic);
-      return;
-    }  
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+      ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    reconnect (ic->h);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL,
+                    _
+                    ("Failed to transmit iteration request to `PEERINFO' service\n"));
+    GNUNET_free (ic);
+    return;
+  }
 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Waiting for response from `%s' service.\n",
-              "PEERINFO");
+              "Waiting for response from `%s' service.\n", "PEERINFO");
 #endif
   ic->h->in_receive = GNUNET_YES;
   ic->in_receive = GNUNET_YES;
   ic->tqe = NULL;
   GNUNET_CLIENT_receive (ic->h->client,
                          &peerinfo_handler,
-                         ic,
-                         GNUNET_TIME_absolute_get_remaining (ic->timeout));
+                         ic, GNUNET_TIME_absolute_get_remaining (ic->timeout));
 }
 
 
@@ -563,21 +540,19 @@ iterator_start_receive (void *cls,
  * @param tc scheduler context
  */
 static void
-signal_timeout (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+signal_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_PEERINFO_IteratorContext *ic = cls;
 
   ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-  if (! ic->in_receive)
-    GNUNET_CONTAINER_DLL_remove (ic->h->tq_head,
-                                 ic->h->tq_tail,
-                                 ic->tqe);
+  if (!ic->in_receive)
+    GNUNET_CONTAINER_DLL_remove (ic->h->tq_head, ic->h->tq_tail, ic->tqe);
   else
     reconnect (ic->h);
   ic->callback (ic->callback_cls,
-                NULL, NULL, 
-                _("Timeout transmitting iteration request to `PEERINFO' service.\n"));
+                NULL, NULL,
+                _
+                ("Timeout transmitting iteration request to `PEERINFO' service.\n"));
   ic->callback = NULL;
   GNUNET_free_non_null (ic->tqe);
   GNUNET_free (ic);
@@ -602,10 +577,9 @@ signal_timeout (void *cls,
  */
 struct GNUNET_PEERINFO_IteratorContext *
 GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,
-                         const struct GNUNET_PeerIdentity *peer,
-                         struct GNUNET_TIME_Relative timeout,
-                         GNUNET_PEERINFO_Processor callback,
-                         void *callback_cls)
+                         const struct GNUNET_PeerIdentity *peer,
+                         struct GNUNET_TIME_Relative timeout,
+                         GNUNET_PEERINFO_Processor callback, void *callback_cls)
 {
   struct GNUNET_MessageHeader *lapm;
   struct ListPeerMessage *lpm;
@@ -613,33 +587,33 @@ GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,
   struct TransmissionQueueEntry *tqe;
 
   if (peer == NULL)
-    {
+  {
 #if DEBUG_PEERINFO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Requesting list of peers from PEERINFO service\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Requesting list of peers from PEERINFO service\n");
 #endif
-      tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
-                           sizeof (struct GNUNET_MessageHeader));
-      tqe->size = sizeof (struct GNUNET_MessageHeader);
-      lapm = (struct GNUNET_MessageHeader *) &tqe[1];
-      lapm->size = htons (sizeof (struct GNUNET_MessageHeader));
-      lapm->type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);
-    }
+    tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
+                         sizeof (struct GNUNET_MessageHeader));
+    tqe->size = sizeof (struct GNUNET_MessageHeader);
+    lapm = (struct GNUNET_MessageHeader *) &tqe[1];
+    lapm->size = htons (sizeof (struct GNUNET_MessageHeader));
+    lapm->type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);
+  }
   else
-    {
+  {
 #if DEBUG_PEERINFO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Requesting information on peer `%4s' from PEERINFO service\n",
-                  GNUNET_i2s (peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Requesting information on peer `%4s' from PEERINFO service\n",
+                GNUNET_i2s (peer));
 #endif
-      tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
-                           sizeof (struct ListPeerMessage));
-      tqe->size = sizeof (struct ListPeerMessage);
-      lpm = (struct ListPeerMessage *) &tqe[1];
-      lpm->header.size = htons (sizeof (struct ListPeerMessage));
-      lpm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET);
-      memcpy (&lpm->peer, peer, sizeof (struct GNUNET_PeerIdentity));
-    }
+    tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
+                         sizeof (struct ListPeerMessage));
+    tqe->size = sizeof (struct ListPeerMessage);
+    lpm = (struct ListPeerMessage *) &tqe[1];
+    lpm->header.size = htons (sizeof (struct ListPeerMessage));
+    lpm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET);
+    memcpy (&lpm->peer, peer, sizeof (struct GNUNET_PeerIdentity));
+  }
   ic = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_IteratorContext));
   ic->h = h;
   ic->tqe = tqe;
@@ -647,16 +621,12 @@ GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,
   ic->callback_cls = callback_cls;
   ic->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   ic->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                                   &signal_timeout,
-                                                   ic);
+                                                   &signal_timeout, ic);
   tqe->timeout = ic->timeout;
   tqe->cont = &iterator_start_receive;
   tqe->cont_cls = ic;
   tqe->timeout = ic->timeout;
-  GNUNET_CONTAINER_DLL_insert_after (h->tq_head,
-                                     h->tq_tail,
-                                     h->tq_tail,
-                                     tqe);
+  GNUNET_CONTAINER_DLL_insert_after (h->tq_head, h->tq_tail, h->tq_tail, tqe);
   trigger_transmit (h);
   return ic;
 }
@@ -671,16 +641,14 @@ void
 GNUNET_PEERINFO_iterate_cancel (struct GNUNET_PEERINFO_IteratorContext *ic)
 {
   if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (ic->timeout_task);
-      ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   ic->callback = NULL;
   if (GNUNET_YES == ic->in_receive)
-    return; /* need to finish processing */
-  GNUNET_CONTAINER_DLL_remove (ic->h->tq_head,
-                               ic->h->tq_tail,
-                               ic->tqe);
+    return;                     /* need to finish processing */
+  GNUNET_CONTAINER_DLL_remove (ic->h->tq_head, ic->h->tq_tail, ic->tqe);
   GNUNET_free (ic->tqe);
   GNUNET_free (ic);
 }
diff --git a/src/peerinfo/peerinfo_api_notify.c b/src/peerinfo/peerinfo_api_notify.c
index eb6e29ce5..0c7474f4a 100644
--- a/src/peerinfo/peerinfo_api_notify.c
+++ b/src/peerinfo/peerinfo_api_notify.c
@@ -76,8 +76,7 @@ struct GNUNET_PEERINFO_NotifyContext
  *
  * @param nc our context
  */
-static void
-request_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
+static void request_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
 
 
 /**
@@ -86,8 +85,7 @@ request_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
  *
  * @param nc our context
  */
-static void
-receive_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
+static void receive_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
 
 
 /**
@@ -95,23 +93,21 @@ receive_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
  *
  * @param cls the 'struct GNUNET_PEERINFO_NotifyContext'
  * @param tc scheduler context
- */ 
+ */
 static void
-reconnect (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_PEERINFO_NotifyContext *nc = cls;
 
   nc->task = GNUNET_SCHEDULER_NO_TASK;
   nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
   if (NULL == nc->client)
-    {
-      /* ugh */
-      nc->task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                               &reconnect,
-                                               nc);
-      return; 
-    }
+  {
+    /* ugh */
+    nc->task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                             &reconnect, nc);
+    return;
+  }
   request_notifications (nc);
 }
 
@@ -124,9 +120,7 @@ reconnect (void *cls,
  * @param msg message received, NULL on timeout or fatal error
  */
 static void
-process_notification (void *cls,
-                      const struct
-                      GNUNET_MessageHeader * msg)
+process_notification (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_PEERINFO_NotifyContext *nc = cls;
   const struct InfoMessage *im;
@@ -134,14 +128,27 @@ process_notification (void *cls,
   uint16_t ms;
 
   if (msg == NULL)
-    {
-      GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
-      reconnect (nc, NULL);
-      return;
-    }
+  {
+    GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
+    reconnect (nc, NULL);
+    return;
+  }
   ms = ntohs (msg->size);
   if ((ms < sizeof (struct InfoMessage)) ||
       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_PEERINFO_INFO))
+  {
+    GNUNET_break (0);
+    GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
+    nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
+    request_notifications (nc);
+    return;
+  }
+  im = (const struct InfoMessage *) msg;
+  hello = NULL;
+  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
+  {
+    hello = (const struct GNUNET_HELLO_Message *) &im[1];
+    if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
     {
       GNUNET_break (0);
       GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
@@ -149,24 +156,11 @@ process_notification (void *cls,
       request_notifications (nc);
       return;
     }
-  im = (const struct InfoMessage *) msg;
-  hello = NULL;
-  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
-    {
-      hello = (const struct GNUNET_HELLO_Message *) &im[1];
-      if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
-        {
-          GNUNET_break (0);
-          GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
-          nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
-          request_notifications (nc);
-          return;
-        }
-    }
+  }
 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received information about peer `%s' from peerinfo database\n",
-              GNUNET_i2s (&im->peer));
+              "Received information about peer `%s' from peerinfo database\n",
+              GNUNET_i2s (&im->peer));
 #endif
   nc->callback (nc->callback_cls, &im->peer, hello, NULL);
   receive_notifications (nc);
@@ -183,9 +177,8 @@ static void
 receive_notifications (struct GNUNET_PEERINFO_NotifyContext *nc)
 {
   GNUNET_CLIENT_receive (nc->client,
-                         &process_notification,
-                         nc,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &process_notification,
+                         nc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -197,22 +190,20 @@ receive_notifications (struct GNUNET_PEERINFO_NotifyContext *nc)
  * @param buf where the callee should write the message
  * @return number of bytes written to buf
  */
-static size_t 
-transmit_notify_request (void *cls,
-                         size_t size, 
-                         void *buf)
+static size_t
+transmit_notify_request (void *cls, size_t size, void *buf)
 {
   struct GNUNET_PEERINFO_NotifyContext *nc = cls;
   struct GNUNET_MessageHeader hdr;
 
   nc->init = NULL;
   if (buf == NULL)
-    {
-      GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
-      nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
-      request_notifications (nc);
-      return 0;
-    }
+  {
+    GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
+    nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
+    request_notifications (nc);
+    return 0;
+  }
   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   hdr.size = htons (sizeof (struct GNUNET_MessageHeader));
   hdr.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_NOTIFY);
@@ -232,12 +223,12 @@ static void
 request_notifications (struct GNUNET_PEERINFO_NotifyContext *nc)
 {
   GNUNET_assert (NULL == nc->init);
-  nc->init =GNUNET_CLIENT_notify_transmit_ready (nc->client,
-                                                 sizeof (struct GNUNET_MessageHeader),
-                                                 GNUNET_TIME_UNIT_FOREVER_REL,
-                                                 GNUNET_YES,
-                                                 &transmit_notify_request,
-                                                 nc);
+  nc->init = GNUNET_CLIENT_notify_transmit_ready (nc->client,
+                                                  sizeof (struct
+                                                          GNUNET_MessageHeader),
+                                                  GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  GNUNET_YES,
+                                                  &transmit_notify_request, nc);
 }
 
 
@@ -253,24 +244,23 @@ request_notifications (struct GNUNET_PEERINFO_NotifyContext *nc)
  */
 struct GNUNET_PEERINFO_NotifyContext *
 GNUNET_PEERINFO_notify (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                        GNUNET_PEERINFO_Processor callback,
-                        void *callback_cls)
+                        GNUNET_PEERINFO_Processor callback, void *callback_cls)
 {
   struct GNUNET_PEERINFO_NotifyContext *nc;
   struct GNUNET_CLIENT_Connection *client;
 
   client = GNUNET_CLIENT_connect ("peerinfo", cfg);
   if (client == NULL)
-    {      
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Could not connect to `%s' service.\n"), "peerinfo");
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Could not connect to `%s' service.\n"), "peerinfo");
+    return NULL;
+  }
   nc = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_NotifyContext));
   nc->cfg = cfg;
   nc->client = client;
   nc->callback = callback;
-  nc->callback_cls = callback_cls; 
+  nc->callback_cls = callback_cls;
   request_notifications (nc);
   return nc;
 }
@@ -285,10 +275,10 @@ void
 GNUNET_PEERINFO_notify_cancel (struct GNUNET_PEERINFO_NotifyContext *nc)
 {
   if (NULL != nc->init)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (nc->init);
-      nc->init = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (nc->init);
+    nc->init = NULL;
+  }
   if (NULL != nc->client)
     GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
   if (GNUNET_SCHEDULER_NO_TASK != nc->task)
diff --git a/src/peerinfo/perf_peerinfo_api.c b/src/peerinfo/perf_peerinfo_api.c
index 4f490671e..d0eadaf94 100755
--- a/src/peerinfo/perf_peerinfo_api.c
+++ b/src/peerinfo/perf_peerinfo_api.c
@@ -54,12 +54,9 @@ check_it (void *cls,
 {
 #if DEBUG
   if (addrlen > 0)
-    {
-      fprintf (stderr,
-               "name: %s, addr: %s\n", 
-               tname, 
-               (const char*) addr);
-    }
+  {
+    fprintf (stderr, "name: %s, addr: %s\n", tname, (const char *) addr);
+  }
 #endif
   return GNUNET_OK;
 }
@@ -75,13 +72,12 @@ address_generator (void *cls, size_t max, void *buf)
   if (*agc == 0)
     return 0;
 
-  GNUNET_asprintf(&address, "Address%d", *agc);
+  GNUNET_asprintf (&address, "Address%d", *agc);
 
   ret = GNUNET_HELLO_add_address ("peerinfotest",
                                   GNUNET_TIME_relative_to_absolute
-                                  (GNUNET_TIME_UNIT_HOURS), 
-                                  address, strlen(address) + 1,
-                                  buf, max);
+                                  (GNUNET_TIME_UNIT_HOURS),
+                                  address, strlen (address) + 1, buf, max);
   GNUNET_free (address);
   *agc = 0;
   return ret;
@@ -106,53 +102,53 @@ add_peer (size_t i)
 static void
 process (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)
 {
   if (peer == NULL)
-    {
+  {
 #if DEBUG
-      fprintf(stderr, "Process received NULL response\n");
+    fprintf (stderr, "Process received NULL response\n");
 #endif
-    }
+  }
   else
-    {
+  {
 #if DEBUG
-      fprintf(stderr, "Processed a peer\n");
+    fprintf (stderr, "Processed a peer\n");
 #endif
-      numpeers++;
-      if (0 && (hello != NULL))
-        GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_it, NULL);
+    numpeers++;
+    if (0 && (hello != NULL))
+      GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_it, NULL);
 
-    }
+  }
 }
 
 
 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)
 {
   size_t i;
+
   cfg = c;
   h = GNUNET_PEERINFO_connect (cfg);
   GNUNET_assert (h != NULL);
   for (i = 0; i < NUM_REQUESTS; i++)
-    {
-      add_peer (i);
-      ic[i] = GNUNET_PEERINFO_iterate (h,
-                                       NULL,
-                                       GNUNET_TIME_relative_multiply
-                                       (GNUNET_TIME_UNIT_SECONDS, 30),
-                                       &process, cls);
-    }
+  {
+    add_peer (i);
+    ic[i] = GNUNET_PEERINFO_iterate (h,
+                                     NULL,
+                                     GNUNET_TIME_relative_multiply
+                                     (GNUNET_TIME_UNIT_SECONDS, 30),
+                                     &process, cls);
+  }
 }
 
 static int
 check ()
 {
   int ok = 0;
+
   char *const argv[] = { "perf-peerinfo-api",
     "-c",
     "test_peerinfo_api_data.conf",
@@ -165,33 +161,32 @@ check ()
   };
 #if START_SERVICE
   struct GNUNET_OS_Process *proc;
+
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-peerinfo",
-                                 "gnunet-service-peerinfo",
+                                  "gnunet-service-peerinfo",
 #if DEBUG_PEERINFO
-                                 "-L", "DEBUG",
+                                  "-L", "DEBUG",
 #else
-                                "-L", "ERROR",
+                                  "-L", "ERROR",
 #endif
-                                 "-c", "test_peerinfo_api_data.conf", NULL);
+                                  "-c", "test_peerinfo_api_data.conf", NULL);
 #endif
   GNUNET_assert (NULL != proc);
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "perf-peerinfo-api", "nohelp",
-                      options, &run, &ok);
+                      argv, "perf-peerinfo-api", "nohelp", options, &run, &ok);
   fprintf (stderr,
-           "Received %u/%u calls before timeout\n",
-           numpeers,
-           NUM_REQUESTS * NUM_REQUESTS / 2);
+           "Received %u/%u calls before timeout\n",
+           numpeers, NUM_REQUESTS * NUM_REQUESTS / 2);
   GAUGER ("PEERINFO", "Peerinfo lookups", numpeers / 30, "peers/s");
 #if START_SERVICE
   if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      ok = 1;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    ok = 1;
+  }
   GNUNET_OS_process_wait (proc);
   GNUNET_OS_process_close (proc);
   proc = NULL;
diff --git a/src/peerinfo/test_peerinfo_api.c b/src/peerinfo/test_peerinfo_api.c
index 460a3764d..e740f1fc9 100644
--- a/src/peerinfo/test_peerinfo_api.c
+++ b/src/peerinfo/test_peerinfo_api.c
@@ -53,11 +53,11 @@ check_it (void *cls,
   unsigned int *agc = cls;
 
   if (addrlen > 0)
-    {
-      GNUNET_assert (0 == strcmp ("peerinfotest", tname));
-      GNUNET_assert (0 == strncmp ("Address", addr, addrlen));
-      (*agc) -= (1 << (addrlen - 1));
-    }
+  {
+    GNUNET_assert (0 == strcmp ("peerinfotest", tname));
+    GNUNET_assert (0 == strncmp ("Address", addr, addrlen));
+    (*agc) -= (1 << (addrlen - 1));
+  }
   return GNUNET_OK;
 }
 
@@ -100,67 +100,63 @@ add_peer ()
 static void
 process (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)
 {
   int *ok = cls;
   unsigned int agc;
 
   if (err_msg != NULL)
   {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Error in communication with PEERINFO service\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Error in communication with PEERINFO service\n"));
   }
 
   if (peer == NULL)
+  {
+    ic = NULL;
+    if ((3 == *ok) && (retries < 50))
     {
-      ic = NULL;
-      if ( (3 == *ok) &&
-           (retries < 50) )
-        {
-          /* try again */
-          retries++;      
-          add_peer ();
-          ic = GNUNET_PEERINFO_iterate (h,
-                                        NULL,
-                                        GNUNET_TIME_relative_multiply
-                                        (GNUNET_TIME_UNIT_SECONDS, 15), 
-                                        &process, cls);
-          return;
-        }
-      GNUNET_assert (peer == NULL);
-      GNUNET_assert (2 == *ok);
-      GNUNET_PEERINFO_disconnect (h);
-      h = NULL;
-      *ok = 0;
+      /* try again */
+      retries++;
+      add_peer ();
+      ic = GNUNET_PEERINFO_iterate (h,
+                                    NULL,
+                                    GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_SECONDS, 15),
+                                    &process, cls);
       return;
     }
+    GNUNET_assert (peer == NULL);
+    GNUNET_assert (2 == *ok);
+    GNUNET_PEERINFO_disconnect (h);
+    h = NULL;
+    *ok = 0;
+    return;
+  }
   if (hello != NULL)
-    {
-      GNUNET_assert (3 == *ok);
-      agc = 3;
-      GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_it, &agc);
-      GNUNET_assert (agc == 0);
-      *ok = 2;
-    }
+  {
+    GNUNET_assert (3 == *ok);
+    agc = 3;
+    GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_it, &agc);
+    GNUNET_assert (agc == 0);
+    *ok = 2;
+  }
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile, 
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   cfg = c;
   h = GNUNET_PEERINFO_connect (cfg);
   GNUNET_assert (h != NULL);
   add_peer ();
   ic = GNUNET_PEERINFO_iterate (h,
-                                NULL,
-                                GNUNET_TIME_relative_multiply
-                                (GNUNET_TIME_UNIT_SECONDS, 15),
-                                &process, cls);
+                                NULL,
+                                GNUNET_TIME_relative_multiply
+                                (GNUNET_TIME_UNIT_SECONDS, 15), &process, cls);
 }
 
 
@@ -169,6 +165,7 @@ check ()
 {
   int ok = 3;
   struct GNUNET_OS_Process *proc;
+
   char *const argv[] = { "test-peerinfo-api",
     "-c",
     "test_peerinfo_api_data.conf",
@@ -181,20 +178,19 @@ check ()
     GNUNET_GETOPT_OPTION_END
   };
   proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-peerinfo",
-                                 "gnunet-service-peerinfo",
+                                  "gnunet-service-peerinfo",
 #if DEBUG_PEERINFO
-                                 "-L", "DEBUG",
+                                  "-L", "DEBUG",
 #endif
-                                 "-c", "test_peerinfo_api_data.conf", NULL);
+                                  "-c", "test_peerinfo_api_data.conf", NULL);
   GNUNET_assert (NULL != proc);
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-peerinfo-api", "nohelp",
-                      options, &run, &ok);
+                      argv, "test-peerinfo-api", "nohelp", options, &run, &ok);
   if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      ok = 1;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    ok = 1;
+  }
   GNUNET_OS_process_wait (proc);
   GNUNET_OS_process_close (proc);
   proc = NULL;