10 files changed, 3440 insertions, 3757 deletions

diff --git a/src/core/core_api.c b/src/core/core_api.c
index 7f7928fd3..c6fcc0b47 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -116,7 +116,7 @@ struct PeerRecord
    * SendMessageRequest ID generator for this peer.
    */
   uint16_t smr_id_gen;
-  
+
 };
 
 
@@ -143,7 +143,7 @@ struct ControlMessage
    * Function to run after transmission failed/succeeded.
    */
   GNUNET_CORE_ControlContinuation cont;
-  
+
   /**
    * Closure for 'cont'.
    */
@@ -190,9 +190,9 @@ struct GNUNET_CORE_Handle
 
   /**
    * Function to call whenever we're notified about a peer changing status.
-   */  
+   */
   GNUNET_CORE_PeerStatusEventHandler status_events;
-  
+
   /**
    * Function to call whenever we receive an inbound message.
    */
@@ -371,8 +371,7 @@ struct GNUNET_CORE_TransmitHandle
  *
  * @param h our handle to the core service
  */
-static void
-reconnect (struct GNUNET_CORE_Handle *h);
+static void reconnect (struct GNUNET_CORE_Handle *h);
 
 
 /**
@@ -382,15 +381,14 @@ reconnect (struct GNUNET_CORE_Handle *h);
  * @param tc task 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_CORE_Handle *h = cls;
 
   h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connecting to CORE service after delay\n");
+              "Connecting to CORE service after delay\n");
 #endif
   reconnect (h);
 }
@@ -407,8 +405,7 @@ reconnect_task (void *cls,
  */
 static int
 disconnect_and_free_peer_entry (void *cls,
-                                const GNUNET_HashCode *key,
-                                void *value)
+                                const GNUNET_HashCode * key, void *value)
 {
   static struct GNUNET_BANDWIDTH_Value32NBO zero;
   struct GNUNET_CORE_Handle *h = cls;
@@ -418,61 +415,47 @@ disconnect_and_free_peer_entry (void *cls,
   void *pcic_cls;
 
   if (pr->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (pr->timeout_task);
-      pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pr->timeout_task);
+    pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (pr->ntr_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (pr->ntr_task);
-      pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if ( (pr->prev != NULL) ||
-       (pr->next != NULL) ||
-       (h->ready_peer_head == pr) )
-    GNUNET_CONTAINER_DLL_remove (h->ready_peer_head,
-                                 h->ready_peer_tail,
-                                 pr);
+  {
+    GNUNET_SCHEDULER_cancel (pr->ntr_task);
+    pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if ((pr->prev != NULL) || (pr->next != NULL) || (h->ready_peer_head == pr))
+    GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
   if (h->disconnects != NULL)
-    h->disconnects (h->cls,
-                    &pr->peer);
+    h->disconnects (h->cls, &pr->peer);
   /* all requests should have been cancelled, clean up anyway, just in case */
   GNUNET_break (pr->queue_size == 0);
   if (NULL != (pcic = pr->pcic))
-    {
-      GNUNET_break (0);
-      pcic_cls = pr->pcic_cls;
-      GNUNET_CORE_peer_change_preference_cancel (pr->pcic_ptr);
-      pcic (pcic_cls,
-            &pr->peer,
-            zero,
-            0, 
-            GNUNET_TIME_UNIT_FOREVER_REL,
-            0);
-    }
+  {
+    GNUNET_break (0);
+    pcic_cls = pr->pcic_cls;
+    GNUNET_CORE_peer_change_preference_cancel (pr->pcic_ptr);
+    pcic (pcic_cls, &pr->peer, zero, 0, GNUNET_TIME_UNIT_FOREVER_REL, 0);
+  }
   while (NULL != (th = pr->pending_head))
-    {
-      GNUNET_break (0);
-      GNUNET_CONTAINER_DLL_remove (pr->pending_head,
-                                   pr->pending_tail,
-                                   th);
-      pr->queue_size--;
-      if (th->cm != NULL)
-        th->cm->th = NULL;
-      GNUNET_free (th);
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_CONTAINER_DLL_remove (pr->pending_head, pr->pending_tail, th);
+    pr->queue_size--;
+    if (th->cm != NULL)
+      th->cm->th = NULL;
+    GNUNET_free (th);
+  }
   /* done with 'voluntary' cleanups, now on to normal freeing */
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (h->peers,
-                                                       key,
-                                                       pr));
+                 GNUNET_CONTAINER_multihashmap_remove (h->peers, key, pr));
   GNUNET_assert (pr->pending_head == NULL);
   GNUNET_assert (pr->pending_tail == NULL);
   GNUNET_assert (pr->ch = h);
   GNUNET_assert (pr->queue_size == 0);
   GNUNET_assert (pr->timeout_task == GNUNET_SCHEDULER_NO_TASK);
   GNUNET_assert (pr->ntr_task == GNUNET_SCHEDULER_NO_TASK);
-  GNUNET_free (pr);  
+  GNUNET_free (pr);
   return GNUNET_YES;
 }
 
@@ -491,41 +474,36 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
 
   GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
   if (NULL != h->cth)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
-      h->cth = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
+    h->cth = NULL;
+  }
   if (h->client != NULL)
-    {
-      GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
-      h->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
+    h->client = NULL;
+  }
   h->currently_down = GNUNET_YES;
   GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
   h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
-                                                    &reconnect_task,
-                                                    h);
+                                                    &reconnect_task, h);
   while (NULL != (cm = h->control_pending_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
-                                   h->control_pending_tail,
-                                   cm);
-      if (cm->th != NULL)
-        cm->th->cm = NULL; 
-      if (cm->cont != NULL)
-        cm->cont (cm->cont_cls, GNUNET_NO);
-      GNUNET_free (cm);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
+                                 h->control_pending_tail, cm);
+    if (cm->th != NULL)
+      cm->th->cm = NULL;
+    if (cm->cont != NULL)
+      cm->cont (cm->cont_cls, GNUNET_NO);
+    GNUNET_free (cm);
+  }
   GNUNET_CONTAINER_multihashmap_iterate (h->peers,
-                                         &disconnect_and_free_peer_entry,
-                                         h);
-  while (NULL != (pr = h->ready_peer_head))    
-    GNUNET_CONTAINER_DLL_remove (h->ready_peer_head,
-                                 h->ready_peer_tail,
-                                 pr);
+                                         &disconnect_and_free_peer_entry, h);
+  while (NULL != (pr = h->ready_peer_head))
+    GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
   GNUNET_assert (h->control_pending_head == NULL);
   h->retry_backoff = GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_SECONDS,
-                                               h->retry_backoff);
+                                               h->retry_backoff);
   h->retry_backoff = GNUNET_TIME_relative_multiply (h->retry_backoff, 2);
 }
 
@@ -538,8 +516,7 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
  * @param ignore_currently_down transmit message even if not initialized?
  */
 static void
-trigger_next_request (struct GNUNET_CORE_Handle *h,
-                      int ignore_currently_down);
+trigger_next_request (struct GNUNET_CORE_Handle *h, int ignore_currently_down);
 
 
 /**
@@ -550,8 +527,7 @@ trigger_next_request (struct GNUNET_CORE_Handle *h,
  * @param tc context, can be NULL (!)
  */
 static void
-transmission_timeout (void *cls, 
-                      const struct GNUNET_SCHEDULER_TaskContext *tc);
+transmission_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -569,27 +545,27 @@ request_next_transmission (struct PeerRecord *pr)
   struct GNUNET_CORE_TransmitHandle *th;
 
   if (pr->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (pr->timeout_task);
-      pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pr->timeout_task);
+    pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL == (th = pr->pending_head))
-    {
-      trigger_next_request (h, GNUNET_NO);
-      return;
-    }
+  {
+    trigger_next_request (h, GNUNET_NO);
+    return;
+  }
   if (th->cm != NULL)
-    return; /* already done */
+    return;                     /* already done */
   GNUNET_assert (pr->prev == NULL);
   GNUNET_assert (pr->next == NULL);
-  pr->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining (th->timeout),
-                                                   &transmission_timeout,
-                                                   pr);
-  cm = GNUNET_malloc (sizeof (struct ControlMessage) + 
-                      sizeof (struct SendMessageRequest));
+  pr->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
+                                    (th->timeout), &transmission_timeout, pr);
+  cm = GNUNET_malloc (sizeof (struct ControlMessage) +
+                      sizeof (struct SendMessageRequest));
   th->cm = cm;
   cm->th = th;
-  smr = (struct SendMessageRequest*) &cm[1];
+  smr = (struct SendMessageRequest *) &cm[1];
   smr->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
   smr->header.size = htons (sizeof (struct SendMessageRequest));
   smr->priority = htonl (th->priority);
@@ -599,12 +575,11 @@ request_next_transmission (struct PeerRecord *pr)
   smr->size = htons (th->msize);
   smr->smr_id = htons (th->smr_id = pr->smr_id_gen++);
   GNUNET_CONTAINER_DLL_insert_tail (h->control_pending_head,
-                                    h->control_pending_tail,
-                                    cm);
+                                    h->control_pending_tail, cm);
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding SEND REQUEST for peer `%s' to message queue\n",
-              GNUNET_i2s (&pr->peer));
+              "Adding SEND REQUEST for peer `%s' to message queue\n",
+              GNUNET_i2s (&pr->peer));
 #endif
   trigger_next_request (h, GNUNET_NO);
 }
@@ -618,33 +593,26 @@ request_next_transmission (struct PeerRecord *pr)
  * @param tc context, can be NULL (!)
  */
 static void
-transmission_timeout (void *cls, 
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmission_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PeerRecord *pr = cls;
   struct GNUNET_CORE_Handle *h = pr->ch;
   struct GNUNET_CORE_TransmitHandle *th;
-  
+
   pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   th = pr->pending_head;
-  GNUNET_CONTAINER_DLL_remove (pr->pending_head,
-                               pr->pending_tail,
-                               th);
+  GNUNET_CONTAINER_DLL_remove (pr->pending_head, pr->pending_tail, th);
   pr->queue_size--;
-  if ( (pr->prev != NULL) ||
-       (pr->next != NULL) ||
-       (pr == h->ready_peer_head) )
-    {
-      /* the request that was 'approved' by core was
-         canceled before it could be transmitted; remove
-         us from the 'ready' list */
-      GNUNET_CONTAINER_DLL_remove (h->ready_peer_head,
-                                   h->ready_peer_tail,
-                                   pr);
-    }
+  if ((pr->prev != NULL) || (pr->next != NULL) || (pr == h->ready_peer_head))
+  {
+    /* the request that was 'approved' by core was
+     * canceled before it could be transmitted; remove
+     * us from the 'ready' list */
+    GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
+  }
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Signalling timeout of request for transmission to CORE service\n");
+              "Signalling timeout of request for transmission to CORE service\n");
 #endif
   request_next_transmission (pr);
   GNUNET_assert (0 == th->get_message (th->get_message_cls, 0, NULL));
@@ -656,9 +624,7 @@ transmission_timeout (void *cls,
  * Transmit the next message to the core service.
  */
 static size_t
-transmit_message (void *cls,
-                  size_t size, 
-                  void *buf)
+transmit_message (void *cls, size_t size, void *buf)
 {
   struct GNUNET_CORE_Handle *h = cls;
   struct ControlMessage *cm;
@@ -672,117 +638,108 @@ transmit_message (void *cls,
   GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
   h->cth = NULL;
   if (buf == NULL)
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission failed, initiating reconnect\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission failed, initiating reconnect\n");
 #endif
-      reconnect_later (h);
-      return 0;
-    }
+    reconnect_later (h);
+    return 0;
+  }
   /* first check for control messages */
   if (NULL != (cm = h->control_pending_head))
+  {
+    hdr = (const struct GNUNET_MessageHeader *) &cm[1];
+    msize = ntohs (hdr->size);
+    if (size < msize)
     {
-      hdr = (const struct GNUNET_MessageHeader*) &cm[1];
-      msize = ntohs (hdr->size);
-      if (size < msize)
-        {
-          trigger_next_request (h, GNUNET_NO);
-          return 0;
-        }
-#if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting control message with %u bytes of type %u to core.\n",
-                  (unsigned int) msize,
-                  (unsigned int) ntohs (hdr->type));
-#endif
-      memcpy (buf, hdr, msize);
-      GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
-                                   h->control_pending_tail,
-                                   cm);     
-      if (cm->th != NULL)
-        cm->th->cm = NULL;
-      if (NULL != cm->cont)
-        cm->cont (cm->cont_cls, GNUNET_OK);
-      GNUNET_free (cm);
       trigger_next_request (h, GNUNET_NO);
-      return msize;
+      return 0;
     }
+#if DEBUG_CORE
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting control message with %u bytes of type %u to core.\n",
+                (unsigned int) msize, (unsigned int) ntohs (hdr->type));
+#endif
+    memcpy (buf, hdr, msize);
+    GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
+                                 h->control_pending_tail, cm);
+    if (cm->th != NULL)
+      cm->th->cm = NULL;
+    if (NULL != cm->cont)
+      cm->cont (cm->cont_cls, GNUNET_OK);
+    GNUNET_free (cm);
+    trigger_next_request (h, GNUNET_NO);
+    return msize;
+  }
   /* now check for 'ready' P2P messages */
   if (NULL != (pr = h->ready_peer_head))
+  {
+    GNUNET_assert (pr->pending_head != NULL);
+    th = pr->pending_head;
+    if (size < th->msize + sizeof (struct SendMessage))
+    {
+      trigger_next_request (h, GNUNET_NO);
+      return 0;
+    }
+    GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
+    GNUNET_CONTAINER_DLL_remove (pr->pending_head, pr->pending_tail, th);
+    pr->queue_size--;
+    if (pr->timeout_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_assert (pr->pending_head != NULL);
-      th = pr->pending_head;
-      if (size < th->msize + sizeof (struct SendMessage))
-        {
-          trigger_next_request (h, GNUNET_NO);
-          return 0;
-        }
-      GNUNET_CONTAINER_DLL_remove (h->ready_peer_head,
-                                   h->ready_peer_tail,
-                                   pr);
-      GNUNET_CONTAINER_DLL_remove (pr->pending_head,
-                                   pr->pending_tail,
-                                   th);
-      pr->queue_size--;
-      if (pr->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (pr->timeout_task);
-          pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-        }
+      GNUNET_SCHEDULER_cancel (pr->timeout_task);
+      pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    }
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting SEND request to `%s' with %u bytes.\n",
-                  GNUNET_i2s (&pr->peer),
-                  (unsigned int) th->msize);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting SEND request to `%s' with %u bytes.\n",
+                GNUNET_i2s (&pr->peer), (unsigned int) th->msize);
 #endif
-      sm = (struct SendMessage *) buf;
-      sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SEND);
-      sm->priority = htonl (th->priority);
-      sm->deadline = GNUNET_TIME_absolute_hton (th->timeout);
-      sm->peer = pr->peer;
-      sm->cork = htonl ((uint32_t) th->cork);
-      sm->reserved = htonl (0);
-      ret = th->get_message (th->get_message_cls,
-                             size - sizeof (struct SendMessage),
-                             &sm[1]);
- 
+    sm = (struct SendMessage *) buf;
+    sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SEND);
+    sm->priority = htonl (th->priority);
+    sm->deadline = GNUNET_TIME_absolute_hton (th->timeout);
+    sm->peer = pr->peer;
+    sm->cork = htonl ((uint32_t) th->cork);
+    sm->reserved = htonl (0);
+    ret = th->get_message (th->get_message_cls,
+                           size - sizeof (struct SendMessage), &sm[1]);
+
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting SEND request to `%s' yielded %u bytes.\n",
-                  GNUNET_i2s (&pr->peer),
-                  ret);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting SEND request to `%s' yielded %u bytes.\n",
+                GNUNET_i2s (&pr->peer), ret);
 #endif
-      GNUNET_free (th);
-     if (0 == ret)
-        {
+    GNUNET_free (th);
+    if (0 == ret)
+    {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Size of clients message to peer %s is 0!\n",
-                      GNUNET_i2s(&pr->peer));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Size of clients message to peer %s is 0!\n",
+                  GNUNET_i2s (&pr->peer));
 #endif
-          /* client decided to send nothing! */
-          request_next_transmission (pr);
-          return 0;       
-        }
+      /* client decided to send nothing! */
+      request_next_transmission (pr);
+      return 0;
+    }
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Produced SEND message to core with %u bytes payload\n",
-                  (unsigned int) ret);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Produced SEND message to core with %u bytes payload\n",
+                (unsigned int) ret);
 #endif
-      GNUNET_assert (ret >= sizeof (struct GNUNET_MessageHeader));
-      if (ret + sizeof (struct SendMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-        {
-          GNUNET_break (0);
-          request_next_transmission (pr);
-          return 0;
-        }
-      ret += sizeof (struct SendMessage);
-      sm->header.size = htons (ret);
-      GNUNET_assert (ret <= size);
+    GNUNET_assert (ret >= sizeof (struct GNUNET_MessageHeader));
+    if (ret + sizeof (struct SendMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+    {
+      GNUNET_break (0);
       request_next_transmission (pr);
-      return ret;
+      return 0;
     }
+    ret += sizeof (struct SendMessage);
+    sm->header.size = htons (ret);
+    GNUNET_assert (ret <= size);
+    request_next_transmission (pr);
+    return ret;
+  }
   return 0;
 }
 
@@ -795,45 +752,46 @@ transmit_message (void *cls,
  * @param ignore_currently_down transmit message even if not initialized?
  */
 static void
-trigger_next_request (struct GNUNET_CORE_Handle *h,
-                      int ignore_currently_down)
+trigger_next_request (struct GNUNET_CORE_Handle *h, int ignore_currently_down)
 {
   uint16_t msize;
 
-  if ( (GNUNET_YES == h->currently_down) &&
-       (ignore_currently_down == GNUNET_NO) )
-    {
+  if ((GNUNET_YES == h->currently_down) && (ignore_currently_down == GNUNET_NO))
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Core connection down, not processing queue\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Core connection down, not processing queue\n");
 #endif
-      return;
-    }
+    return;
+  }
   if (NULL != h->cth)
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Request pending, not processing queue\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Request pending, not processing queue\n");
 #endif
-      return;
-    }
+    return;
+  }
   if (h->control_pending_head != NULL)
-    msize = ntohs (((struct GNUNET_MessageHeader*) &h->control_pending_head[1])->size);    
-  else if (h->ready_peer_head != NULL) 
-    msize = h->ready_peer_head->pending_head->msize + sizeof (struct SendMessage);    
+    msize =
+        ntohs (((struct GNUNET_MessageHeader *) &h->
+                control_pending_head[1])->size);
+  else if (h->ready_peer_head != NULL)
+    msize =
+        h->ready_peer_head->pending_head->msize + sizeof (struct SendMessage);
   else
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Request queue empty, not processing queue\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Request queue empty, not processing queue\n");
 #endif
-      return; /* no pending message */
-    }
+    return;                     /* no pending message */
+  }
   h->cth = GNUNET_CLIENT_notify_transmit_ready (h->client,
-                                                msize,
-                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                                GNUNET_NO,
-                                                &transmit_message, h);
+                                                msize,
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                GNUNET_NO,
+                                                &transmit_message, h);
 }
 
 
@@ -844,8 +802,7 @@ trigger_next_request (struct GNUNET_CORE_Handle *h,
  * @param msg the message received from the core service
  */
 static void
-main_notify_handler (void *cls, 
-                     const struct GNUNET_MessageHeader *msg)
+main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_CORE_Handle *h = cls;
   const struct InitReplyMessage *m;
@@ -868,13 +825,13 @@ main_notify_handler (void *cls,
   uint32_t ats_count;
 
   if (msg == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _
-                  ("Client was disconnected from core service, trying to reconnect.\n"));
-      reconnect_later (h);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Client was disconnected from core service, trying to reconnect.\n"));
+    reconnect_later (h);
+    return;
+  }
   msize = ntohs (msg->size);
 #if DEBUG_CORE > 2
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -882,425 +839,401 @@ main_notify_handler (void *cls,
               ntohs (msg->type), msize);
 #endif
   switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY:
+    if (ntohs (msg->size) != sizeof (struct InitReplyMessage))
     {
-    case GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY:
-      if (ntohs (msg->size) != sizeof (struct InitReplyMessage))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      m = (const struct InitReplyMessage *) msg;
-      GNUNET_break (0 == ntohl (m->reserved));
-      /* start our message processing loop */
-      if (GNUNET_YES == h->currently_down)
-        {
-          h->currently_down = GNUNET_NO;
-          trigger_next_request (h, GNUNET_NO);
-        }
-      h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
-      GNUNET_CRYPTO_hash (&m->publicKey,
-                          sizeof (struct
-                                  GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                          &h->me.hashPubKey);
-      if (NULL != (init = h->init))
-        {
-          /* mark so we don't call init on reconnect */
-          h->init = NULL;
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    m = (const struct InitReplyMessage *) msg;
+    GNUNET_break (0 == ntohl (m->reserved));
+    /* start our message processing loop */
+    if (GNUNET_YES == h->currently_down)
+    {
+      h->currently_down = GNUNET_NO;
+      trigger_next_request (h, GNUNET_NO);
+    }
+    h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+    GNUNET_CRYPTO_hash (&m->publicKey,
+                        sizeof (struct
+                                GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                        &h->me.hashPubKey);
+    if (NULL != (init = h->init))
+    {
+      /* mark so we don't call init on reconnect */
+      h->init = NULL;
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Connected to core service of peer `%s'.\n",
-                      GNUNET_i2s (&h->me));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connected to core service of peer `%s'.\n",
+                  GNUNET_i2s (&h->me));
 #endif
-          init (h->cls, h, &h->me, &m->publicKey);
-        }
-      else
-        {
+      init (h->cls, h, &h->me, &m->publicKey);
+    }
+    else
+    {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Successfully reconnected to core service.\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Successfully reconnected to core service.\n");
 #endif
-        }
-      /* fake 'connect to self' */
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &h->me.hashPubKey);
-      GNUNET_assert (pr == NULL);
-      pr = GNUNET_malloc (sizeof (struct PeerRecord));
-      pr->peer = h->me;
-      pr->ch = h;
-      GNUNET_assert (GNUNET_YES ==
-                     GNUNET_CONTAINER_multihashmap_put (h->peers,
-                                                        &h->me.hashPubKey,
-                                                        pr,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
-      if (NULL != h->connects)
-        h->connects (h->cls,
-                     &h->me,
-                     NULL);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT:
-      if (msize < sizeof (struct ConnectNotifyMessage))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      cnm = (const struct ConnectNotifyMessage *) msg;
-      ats_count = ntohl (cnm->ats_count);
-      if ( (msize != sizeof (struct ConnectNotifyMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) ||
-           (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR != ntohl ((&cnm->ats)[ats_count].type)) )
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
+    }
+    /* fake 'connect to self' */
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &h->me.hashPubKey);
+    GNUNET_assert (pr == NULL);
+    pr = GNUNET_malloc (sizeof (struct PeerRecord));
+    pr->peer = h->me;
+    pr->ch = h;
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_put (h->peers,
+                                                      &h->me.hashPubKey,
+                                                      pr,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+    if (NULL != h->connects)
+      h->connects (h->cls, &h->me, NULL);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT:
+    if (msize < sizeof (struct ConnectNotifyMessage))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    cnm = (const struct ConnectNotifyMessage *) msg;
+    ats_count = ntohl (cnm->ats_count);
+    if ((msize !=
+         sizeof (struct ConnectNotifyMessage) +
+         ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) ||
+        (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR !=
+         ntohl ((&cnm->ats)[ats_count].type)))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received notification about connection from `%s'.\n",
-                  GNUNET_i2s (&cnm->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received notification about connection from `%s'.\n",
+                GNUNET_i2s (&cnm->peer));
 #endif
-      if (0 == memcmp (&h->me,
-                       &cnm->peer,
-                       sizeof (struct GNUNET_PeerIdentity)))
-        {
-          /* connect to self!? */
-          GNUNET_break (0);
-          return;
-        }
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &cnm->peer.hashPubKey);
-      if (pr != NULL)
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      pr = GNUNET_malloc (sizeof (struct PeerRecord));
-      pr->peer = cnm->peer;
-      pr->ch = h;
-      GNUNET_assert (GNUNET_YES ==
-                     GNUNET_CONTAINER_multihashmap_put (h->peers,
-                                                        &cnm->peer.hashPubKey,
-                                                        pr,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
-      if (NULL != h->connects)
-        h->connects (h->cls,
-                     &cnm->peer,
-                     &cnm->ats);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT:
-      if (msize != sizeof (struct DisconnectNotifyMessage))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      dnm = (const struct DisconnectNotifyMessage *) msg;
-      if (0 == memcmp (&h->me,
-                       &dnm->peer,
-                       sizeof (struct GNUNET_PeerIdentity)))
-        {
-          /* connection to self!? */
-          GNUNET_break (0);
-          return;
-        }
-      GNUNET_break (0 == ntohl (dnm->reserved));
+    if (0 == memcmp (&h->me, &cnm->peer, sizeof (struct GNUNET_PeerIdentity)))
+    {
+      /* connect to self!? */
+      GNUNET_break (0);
+      return;
+    }
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &cnm->peer.hashPubKey);
+    if (pr != NULL)
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    pr = GNUNET_malloc (sizeof (struct PeerRecord));
+    pr->peer = cnm->peer;
+    pr->ch = h;
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_put (h->peers,
+                                                      &cnm->peer.hashPubKey,
+                                                      pr,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+    if (NULL != h->connects)
+      h->connects (h->cls, &cnm->peer, &cnm->ats);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT:
+    if (msize != sizeof (struct DisconnectNotifyMessage))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    dnm = (const struct DisconnectNotifyMessage *) msg;
+    if (0 == memcmp (&h->me, &dnm->peer, sizeof (struct GNUNET_PeerIdentity)))
+    {
+      /* connection to self!? */
+      GNUNET_break (0);
+      return;
+    }
+    GNUNET_break (0 == ntohl (dnm->reserved));
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received notification about disconnect from `%s'.\n",
-                  GNUNET_i2s (&dnm->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received notification about disconnect from `%s'.\n",
+                GNUNET_i2s (&dnm->peer));
 #endif
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &dnm->peer.hashPubKey);
-      if (pr == NULL)
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      trigger = ( (pr->prev != NULL) ||
-                  (pr->next != NULL) ||
-                  (h->ready_peer_head == pr) );
-      disconnect_and_free_peer_entry (h, &dnm->peer.hashPubKey, pr);
-      if (trigger)
-        trigger_next_request (h, GNUNET_NO);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_STATUS_CHANGE:
-      if (NULL == h->status_events)
-        {
-          GNUNET_break (0);
-          return;
-        }
-      if (msize < sizeof (struct PeerStatusNotifyMessage))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      psnm = (const struct PeerStatusNotifyMessage *) msg;
-      if (0 == memcmp (&h->me,
-                       &psnm->peer,
-                       sizeof (struct GNUNET_PeerIdentity)))
-        {
-          /* self-change!? */
-          GNUNET_break (0);
-          return;
-        }
-      ats_count = ntohl (psnm->ats_count);
-      if ( (msize != sizeof (struct PeerStatusNotifyMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) ||
-           (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR != ntohl ((&psnm->ats)[ats_count].type)) )
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &dnm->peer.hashPubKey);
+    if (pr == NULL)
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    trigger = ((pr->prev != NULL) ||
+               (pr->next != NULL) || (h->ready_peer_head == pr));
+    disconnect_and_free_peer_entry (h, &dnm->peer.hashPubKey, pr);
+    if (trigger)
+      trigger_next_request (h, GNUNET_NO);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_STATUS_CHANGE:
+    if (NULL == h->status_events)
+    {
+      GNUNET_break (0);
+      return;
+    }
+    if (msize < sizeof (struct PeerStatusNotifyMessage))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    psnm = (const struct PeerStatusNotifyMessage *) msg;
+    if (0 == memcmp (&h->me, &psnm->peer, sizeof (struct GNUNET_PeerIdentity)))
+    {
+      /* self-change!? */
+      GNUNET_break (0);
+      return;
+    }
+    ats_count = ntohl (psnm->ats_count);
+    if ((msize !=
+         sizeof (struct PeerStatusNotifyMessage) +
+         ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) ||
+        (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR !=
+         ntohl ((&psnm->ats)[ats_count].type)))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
 #if DEBUG_CORE > 1
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received notification about status change by `%s'.\n",
-                  GNUNET_i2s (&psnm->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received notification about status change by `%s'.\n",
+                GNUNET_i2s (&psnm->peer));
 #endif
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &psnm->peer.hashPubKey);
-      if (pr == NULL)
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      h->status_events (h->cls,
-                        &psnm->peer,
-                        psnm->bandwidth_in,
-                        psnm->bandwidth_out,
-                        GNUNET_TIME_absolute_ntoh (psnm->timeout),
-                        &psnm->ats);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND:
-      if (msize < sizeof (struct NotifyTrafficMessage))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      ntm = (const struct NotifyTrafficMessage *) msg;
-
-      ats_count = ntohl (ntm->ats_count);
-      if ( (msize < sizeof (struct NotifyTrafficMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)
-            + sizeof (struct GNUNET_MessageHeader)) ||
-           (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR != ntohl ((&ntm->ats)[ats_count].type)) )
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      em = (const struct GNUNET_MessageHeader *) &(&ntm->ats)[ats_count+1];
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &psnm->peer.hashPubKey);
+    if (pr == NULL)
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    h->status_events (h->cls,
+                      &psnm->peer,
+                      psnm->bandwidth_in,
+                      psnm->bandwidth_out,
+                      GNUNET_TIME_absolute_ntoh (psnm->timeout), &psnm->ats);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND:
+    if (msize < sizeof (struct NotifyTrafficMessage))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    ntm = (const struct NotifyTrafficMessage *) msg;
+
+    ats_count = ntohl (ntm->ats_count);
+    if ((msize <
+         sizeof (struct NotifyTrafficMessage) +
+         ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) +
+         sizeof (struct GNUNET_MessageHeader)) ||
+        (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR !=
+         ntohl ((&ntm->ats)[ats_count].type)))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    em = (const struct GNUNET_MessageHeader *) &(&ntm->ats)[ats_count + 1];
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received message of type %u and size %u from peer `%4s'\n",
-                  ntohs (em->type), 
-                  ntohs (em->size),
-                  GNUNET_i2s (&ntm->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received message of type %u and size %u from peer `%4s'\n",
+                ntohs (em->type), ntohs (em->size), GNUNET_i2s (&ntm->peer));
 #endif
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &ntm->peer.hashPubKey);
-      if (pr == NULL)
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      if ((GNUNET_NO == h->inbound_hdr_only) &&
-          (msize != ntohs (em->size) + sizeof (struct NotifyTrafficMessage) + 
-           + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) )
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      et = ntohs (em->type);
-      for (hpos = 0; hpos < h->hcnt; hpos++)
-        {
-          mh = &h->handlers[hpos];
-          if (mh->type != et)
-            continue;
-          if ((mh->expected_size != ntohs (em->size)) &&
-              (mh->expected_size != 0))
-            {
-              GNUNET_break (0);
-              continue;
-            }
-          if (GNUNET_OK !=
-              h->handlers[hpos].callback (h->cls, &ntm->peer, em,
-                                          &ntm->ats))
-            {
-              /* error in processing, do not process other messages! */
-              break;
-            }
-        }
-      if (NULL != h->inbound_notify)
-        h->inbound_notify (h->cls, &ntm->peer, em,
-                           &ntm->ats);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND:
-      if (msize < sizeof (struct NotifyTrafficMessage))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      ntm = (const struct NotifyTrafficMessage *) msg;
-      if (0 == memcmp (&h->me,
-                       &ntm->peer,
-                       sizeof (struct GNUNET_PeerIdentity)))
-        {
-          /* self-change!? */
-          GNUNET_break (0);
-          return;
-        }
-      ats_count = ntohl (ntm->ats_count);
-      if ( (msize < sizeof (struct NotifyTrafficMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)
-            + sizeof (struct GNUNET_MessageHeader)) ||
-           (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR != ntohl ((&ntm->ats)[ats_count].type)) )
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      em = (const struct GNUNET_MessageHeader *) &(&ntm->ats)[ats_count+1];
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &ntm->peer.hashPubKey);
-      if (pr == NULL)
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &ntm->peer.hashPubKey);
+    if (pr == NULL)
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    if ((GNUNET_NO == h->inbound_hdr_only) &&
+        (msize != ntohs (em->size) + sizeof (struct NotifyTrafficMessage) +
+         +ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    et = ntohs (em->type);
+    for (hpos = 0; hpos < h->hcnt; hpos++)
+    {
+      mh = &h->handlers[hpos];
+      if (mh->type != et)
+        continue;
+      if ((mh->expected_size != ntohs (em->size)) && (mh->expected_size != 0))
+      {
+        GNUNET_break (0);
+        continue;
+      }
+      if (GNUNET_OK !=
+          h->handlers[hpos].callback (h->cls, &ntm->peer, em, &ntm->ats))
+      {
+        /* error in processing, do not process other messages! */
+        break;
+      }
+    }
+    if (NULL != h->inbound_notify)
+      h->inbound_notify (h->cls, &ntm->peer, em, &ntm->ats);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND:
+    if (msize < sizeof (struct NotifyTrafficMessage))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    ntm = (const struct NotifyTrafficMessage *) msg;
+    if (0 == memcmp (&h->me, &ntm->peer, sizeof (struct GNUNET_PeerIdentity)))
+    {
+      /* self-change!? */
+      GNUNET_break (0);
+      return;
+    }
+    ats_count = ntohl (ntm->ats_count);
+    if ((msize <
+         sizeof (struct NotifyTrafficMessage) +
+         ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) +
+         sizeof (struct GNUNET_MessageHeader)) ||
+        (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR !=
+         ntohl ((&ntm->ats)[ats_count].type)))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    em = (const struct GNUNET_MessageHeader *) &(&ntm->ats)[ats_count + 1];
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &ntm->peer.hashPubKey);
+    if (pr == NULL)
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received notification about transmission to `%s'.\n",
-                  GNUNET_i2s (&ntm->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received notification about transmission to `%s'.\n",
+                GNUNET_i2s (&ntm->peer));
 #endif
-      if ((GNUNET_NO == h->outbound_hdr_only) &&
-          (msize != ntohs (em->size) + sizeof (struct NotifyTrafficMessage) 
-           + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) )
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      if (NULL == h->outbound_notify)
-        {
-          GNUNET_break (0);
-          break;
-        }
-      h->outbound_notify (h->cls, &ntm->peer, em,
-                          &ntm->ats);
+    if ((GNUNET_NO == h->outbound_hdr_only) &&
+        (msize != ntohs (em->size) + sizeof (struct NotifyTrafficMessage)
+         + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    if (NULL == h->outbound_notify)
+    {
+      GNUNET_break (0);
       break;
-    case GNUNET_MESSAGE_TYPE_CORE_SEND_READY:
-      if (msize != sizeof (struct SendMessageReady))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      smr = (const struct SendMessageReady *) msg;
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &smr->peer.hashPubKey);
-      if (pr == NULL)
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
+    }
+    h->outbound_notify (h->cls, &ntm->peer, em, &ntm->ats);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_SEND_READY:
+    if (msize != sizeof (struct SendMessageReady))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    smr = (const struct SendMessageReady *) msg;
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &smr->peer.hashPubKey);
+    if (pr == NULL)
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received notification about transmission readiness to `%s'.\n",
-                  GNUNET_i2s (&smr->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received notification about transmission readiness to `%s'.\n",
+                GNUNET_i2s (&smr->peer));
 #endif
-      if (pr->pending_head == NULL)
-        {
-          /* request must have been cancelled between the original request
-             and the response from core, ignore core's readiness */
-          break;
-        }
-
-      th = pr->pending_head;
-      if (ntohs (smr->smr_id) != th->smr_id)
-        {
-          /* READY message is for expired or cancelled message,
-             ignore! (we should have already sent another request) */
-          break;
-        }
-      if ( (pr->prev != NULL) ||
-           (pr->next != NULL) ||
-           (h->ready_peer_head == pr) )
-        {
-          /* we should not already be on the ready list... */
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      GNUNET_CONTAINER_DLL_insert (h->ready_peer_head,
-                                   h->ready_peer_tail,
-                                   pr);
-      trigger_next_request (h, GNUNET_NO);
+    if (pr->pending_head == NULL)
+    {
+      /* request must have been cancelled between the original request
+       * and the response from core, ignore core's readiness */
+      break;
+    }
+
+    th = pr->pending_head;
+    if (ntohs (smr->smr_id) != th->smr_id)
+    {
+      /* READY message is for expired or cancelled message,
+       * ignore! (we should have already sent another request) */
       break;
-    case GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO:
-      if (ntohs (msg->size) != sizeof (struct ConfigurationInfoMessage))
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      cim = (const struct ConfigurationInfoMessage*) msg;
-      if (0 == memcmp (&h->me,
-                       &cim->peer,
-                       sizeof (struct GNUNET_PeerIdentity)))
-        {
-          /* self-change!? */
-          GNUNET_break (0);
-          return;
-        }
+    }
+    if ((pr->prev != NULL) || (pr->next != NULL) || (h->ready_peer_head == pr))
+    {
+      /* we should not already be on the ready list... */
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    GNUNET_CONTAINER_DLL_insert (h->ready_peer_head, h->ready_peer_tail, pr);
+    trigger_next_request (h, GNUNET_NO);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO:
+    if (ntohs (msg->size) != sizeof (struct ConfigurationInfoMessage))
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    cim = (const struct ConfigurationInfoMessage *) msg;
+    if (0 == memcmp (&h->me, &cim->peer, sizeof (struct GNUNET_PeerIdentity)))
+    {
+      /* self-change!? */
+      GNUNET_break (0);
+      return;
+    }
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received notification about configuration update for `%s' with RIM %u.\n",
-                  GNUNET_i2s (&cim->peer),
-                  (unsigned int) ntohl (cim->rim_id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received notification about configuration update for `%s' with RIM %u.\n",
+                GNUNET_i2s (&cim->peer), (unsigned int) ntohl (cim->rim_id));
 #endif
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                              &cim->peer.hashPubKey);
-      if (pr == NULL)
-        {
-          GNUNET_break (0);
-          reconnect_later (h);
-          return;
-        }
-      if (pr->rim_id != ntohl (cim->rim_id))
-        {
+    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &cim->peer.hashPubKey);
+    if (pr == NULL)
+    {
+      GNUNET_break (0);
+      reconnect_later (h);
+      return;
+    }
+    if (pr->rim_id != ntohl (cim->rim_id))
+    {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Reservation ID mismatch in notification...\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Reservation ID mismatch in notification...\n");
 #endif
-          break;
-        }
-      pcic = pr->pcic;
-      pr->pcic = NULL;
-      GNUNET_free_non_null (pr->pcic_ptr);
-      pr->pcic_ptr = NULL;
-      if (pcic != NULL)
-        pcic (pr->pcic_cls,
-              &pr->peer,
-              cim->bw_out,
-              ntohl (cim->reserved_amount),
-              GNUNET_TIME_relative_ntoh (cim->reserve_delay),
-              GNUNET_ntohll (cim->preference));
       break;
-    default:
-      reconnect_later (h);
-      return;
     }
+    pcic = pr->pcic;
+    pr->pcic = NULL;
+    GNUNET_free_non_null (pr->pcic_ptr);
+    pr->pcic_ptr = NULL;
+    if (pcic != NULL)
+      pcic (pr->pcic_cls,
+            &pr->peer,
+            cim->bw_out,
+            ntohl (cim->reserved_amount),
+            GNUNET_TIME_relative_ntoh (cim->reserve_delay),
+            GNUNET_ntohll (cim->preference));
+    break;
+  default:
+    reconnect_later (h);
+    return;
+  }
   GNUNET_CLIENT_receive (h->client,
-                         &main_notify_handler, h, 
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &main_notify_handler, h, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -1312,27 +1245,24 @@ main_notify_handler (void *cls,
  * @param success were we successful
  */
 static void
-init_done_task (void *cls, 
-                int success)
+init_done_task (void *cls, int success)
 {
   struct GNUNET_CORE_Handle *h = cls;
 
   if (success == GNUNET_SYSERR)
-    return; /* shutdown */
+    return;                     /* shutdown */
   if (success == GNUNET_NO)
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Failed to exchange INIT with core, retrying\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to exchange INIT with core, retrying\n");
 #endif
-      if (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK)
-        reconnect_later (h);
-      return;
-    }
+    if (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK)
+      reconnect_later (h);
+    return;
+  }
   GNUNET_CLIENT_receive (h->client,
-                         &main_notify_handler, 
-                         h, 
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &main_notify_handler, h, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -1353,49 +1283,46 @@ reconnect (struct GNUNET_CORE_Handle *h)
   unsigned int hpos;
 
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Reconnecting to CORE service\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting to CORE service\n");
 #endif
   GNUNET_assert (h->client == NULL);
   GNUNET_assert (h->currently_down == GNUNET_YES);
   h->client = GNUNET_CLIENT_connect ("core", h->cfg);
   if (h->client == NULL)
-    {
-      reconnect_later (h);
-      return;
-    }
+  {
+    reconnect_later (h);
+    return;
+  }
   msize = h->hcnt * sizeof (uint16_t) + sizeof (struct InitMessage);
-  cm = GNUNET_malloc (sizeof (struct ControlMessage) +
-                      msize);
+  cm = GNUNET_malloc (sizeof (struct ControlMessage) + msize);
   cm->cont = &init_done_task;
   cm->cont_cls = h;
-  init = (struct InitMessage*) &cm[1];
+  init = (struct InitMessage *) &cm[1];
   init->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_INIT);
   init->header.size = htons (msize);
   opt = GNUNET_CORE_OPTION_SEND_CONNECT | GNUNET_CORE_OPTION_SEND_DISCONNECT;
   if (h->status_events != NULL)
     opt |= GNUNET_CORE_OPTION_SEND_STATUS_CHANGE;
   if (h->inbound_notify != NULL)
-    {
-      if (h->inbound_hdr_only)
-        opt |= GNUNET_CORE_OPTION_SEND_HDR_INBOUND;
-      else
-        opt |= GNUNET_CORE_OPTION_SEND_FULL_INBOUND;
-    }
+  {
+    if (h->inbound_hdr_only)
+      opt |= GNUNET_CORE_OPTION_SEND_HDR_INBOUND;
+    else
+      opt |= GNUNET_CORE_OPTION_SEND_FULL_INBOUND;
+  }
   if (h->outbound_notify != NULL)
-    {
-      if (h->outbound_hdr_only)
-        opt |= GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND;
-      else
-        opt |= GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND;
-    }
+  {
+    if (h->outbound_hdr_only)
+      opt |= GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND;
+    else
+      opt |= GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND;
+  }
   init->options = htonl (opt);
-  ts = (uint16_t *) &init[1];
+  ts = (uint16_t *) & init[1];
   for (hpos = 0; hpos < h->hcnt; hpos++)
     ts[hpos] = htons (h->handlers[hpos].type);
   GNUNET_CONTAINER_DLL_insert (h->control_pending_head,
-                               h->control_pending_tail,
-                               cm);
+                               h->control_pending_tail, cm);
   trigger_next_request (h, GNUNET_YES);
 }
 
@@ -1427,12 +1354,12 @@ reconnect (struct GNUNET_CORE_Handle *h)
  */
 struct GNUNET_CORE_Handle *
 GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                     unsigned int queue_size,
+                     unsigned int queue_size,
                      void *cls,
                      GNUNET_CORE_StartupCallback init,
                      GNUNET_CORE_ConnectEventHandler connects,
                      GNUNET_CORE_DisconnectEventHandler disconnects,
-                     GNUNET_CORE_PeerStatusEventHandler status_events,
+                     GNUNET_CORE_PeerStatusEventHandler status_events,
                      GNUNET_CORE_MessageCallback inbound_notify,
                      int inbound_hdr_only,
                      GNUNET_CORE_MessageCallback outbound_notify,
@@ -1464,8 +1391,7 @@ GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                  (GNUNET_SERVER_MAX_MESSAGE_SIZE -
                   sizeof (struct InitMessage)) / sizeof (uint16_t));
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connecting to CORE service\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service\n");
 #endif
   reconnect (h);
   return h;
@@ -1483,40 +1409,38 @@ void
 GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
 {
   struct ControlMessage *cm;
-  
+
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting from CORE service\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from CORE service\n");
 #endif
   if (handle->cth != NULL)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (handle->cth);
-      handle->cth = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (handle->cth);
+    handle->cth = NULL;
+  }
   while (NULL != (cm = handle->control_pending_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (handle->control_pending_head,
-                                   handle->control_pending_tail,
-                                   cm);
-      if (cm->th != NULL)
-        cm->th->cm = NULL;
-      if (cm->cont != NULL)
-        cm->cont (cm->cont_cls, GNUNET_SYSERR);
-      GNUNET_free (cm);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (handle->control_pending_head,
+                                 handle->control_pending_tail, cm);
+    if (cm->th != NULL)
+      cm->th->cm = NULL;
+    if (cm->cont != NULL)
+      cm->cont (cm->cont_cls, GNUNET_SYSERR);
+    GNUNET_free (cm);
+  }
   if (handle->client != NULL)
-    {
-      GNUNET_CLIENT_disconnect (handle->client, GNUNET_NO);
-      handle->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (handle->client, GNUNET_NO);
+    handle->client = NULL;
+  }
   GNUNET_CONTAINER_multihashmap_iterate (handle->peers,
-                                         &disconnect_and_free_peer_entry,
-                                         handle);
+                                         &disconnect_and_free_peer_entry,
+                                         handle);
   if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (handle->reconnect_task);
-      handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
+    handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_CONTAINER_multihashmap_destroy (handle->peers);
   handle->peers = NULL;
   GNUNET_break (handle->ready_peer_head == NULL);
@@ -1532,7 +1456,7 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
  */
 static void
 run_request_next_transmission (void *cls,
-                               const struct GNUNET_SCHEDULER_TaskContext *tc)
+                               const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PeerRecord *pr = cls;
 
@@ -1562,7 +1486,7 @@ run_request_next_transmission (void *cls,
  */
 struct GNUNET_CORE_TransmitHandle *
 GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
-                                   int cork,
+                                   int cork,
                                    uint32_t priority,
                                    struct GNUNET_TIME_Relative maxdelay,
                                    const struct GNUNET_PeerIdentity *target,
@@ -1576,22 +1500,21 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
   struct GNUNET_CORE_TransmitHandle *prev;
   struct GNUNET_CORE_TransmitHandle *minp;
 
-  pr = GNUNET_CONTAINER_multihashmap_get (handle->peers,
-                                          &target->hashPubKey);
+  pr = GNUNET_CONTAINER_multihashmap_get (handle->peers, &target->hashPubKey);
   if (NULL == pr)
-    {
-      /* attempt to send to peer that is not connected */
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Attempting to send to peer `%s' from peer `%s', but not connected!\n",
-                 GNUNET_i2s(target), GNUNET_h2s(&handle->me.hashPubKey));
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+    /* attempt to send to peer that is not connected */
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Attempting to send to peer `%s' from peer `%s', but not connected!\n",
+                GNUNET_i2s (target), GNUNET_h2s (&handle->me.hashPubKey));
+    GNUNET_break (0);
+    return NULL;
+  }
   GNUNET_assert (notify_size + sizeof (struct SendMessage) <
                  GNUNET_SERVER_MAX_MESSAGE_SIZE);
   th = GNUNET_malloc (sizeof (struct GNUNET_CORE_TransmitHandle));
   th->peer = pr;
-  GNUNET_assert(NULL != notify);
+  GNUNET_assert (NULL != notify);
   th->get_message = notify;
   th->get_message_cls = notify_cls;
   th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay);
@@ -1600,81 +1523,72 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
   th->cork = cork;
   /* bound queue size */
   if (pr->queue_size == handle->queue_size)
+  {
+    /* find lowest-priority entry, but skip the head of the list */
+    minp = pr->pending_head->next;
+    prev = minp;
+    while (prev != NULL)
+    {
+      if (prev->priority < minp->priority)
+        minp = prev;
+      prev = prev->next;
+    }
+    if (minp == NULL)
     {
-      /* find lowest-priority entry, but skip the head of the list */
-      minp = pr->pending_head->next;
-      prev = minp;
-      while (prev != NULL)
-        {
-          if (prev->priority < minp->priority)
-            minp = prev;
-          prev = prev->next;
-        }
-      if (minp == NULL) 
-        {
-          GNUNET_break (handle->queue_size != 0);
-          GNUNET_break (pr->queue_size == 1);
-          GNUNET_free(th);
+      GNUNET_break (handle->queue_size != 0);
+      GNUNET_break (pr->queue_size == 1);
+      GNUNET_free (th);
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Dropping transmission request: cannot drop queue head and limit is one\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Dropping transmission request: cannot drop queue head and limit is one\n");
 #endif
-          return NULL;
-        }
-      if (priority <= minp->priority)
-        {
+      return NULL;
+    }
+    if (priority <= minp->priority)
+    {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Dropping transmission request: priority too low\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Dropping transmission request: priority too low\n");
 #endif
-          GNUNET_free(th);
-          return NULL; /* priority too low */
-        }
-      GNUNET_CONTAINER_DLL_remove (pr->pending_head,
-                                   pr->pending_tail,
-                                   minp);
-      pr->queue_size--;
-      GNUNET_assert (0 ==
-                     minp->get_message (minp->get_message_cls,
-                                        0, NULL));
-      GNUNET_free (minp);
+      GNUNET_free (th);
+      return NULL;              /* priority too low */
     }
+    GNUNET_CONTAINER_DLL_remove (pr->pending_head, pr->pending_tail, minp);
+    pr->queue_size--;
+    GNUNET_assert (0 == minp->get_message (minp->get_message_cls, 0, NULL));
+    GNUNET_free (minp);
+  }
 
   /* Order entries by deadline, but SKIP 'HEAD' if
-     we're in the 'ready_peer_*' DLL */
+   * we're in the 'ready_peer_*' DLL */
   pos = pr->pending_head;
-  if ( (pr->prev != NULL) ||
-       (pr->next != NULL) ||
-       (pr == handle->ready_peer_head) )
-    {
-      GNUNET_assert (pos != NULL);
-      pos = pos->next; /* skip head */
-    }
+  if ((pr->prev != NULL) ||
+      (pr->next != NULL) || (pr == handle->ready_peer_head))
+  {
+    GNUNET_assert (pos != NULL);
+    pos = pos->next;            /* skip head */
+  }
 
   /* insertion sort */
   prev = pos;
-  while ( (pos != NULL) &&
-          (pos->timeout.abs_value < th->timeout.abs_value) )      
-    {
-      prev = pos;
-      pos = pos->next;
-    }
+  while ((pos != NULL) && (pos->timeout.abs_value < th->timeout.abs_value))
+  {
+    prev = pos;
+    pos = pos->next;
+  }
   GNUNET_CONTAINER_DLL_insert_after (pr->pending_head,
-                                     pr->pending_tail,
-                                     prev,
-                                     th);
+                                     pr->pending_tail, prev, th);
   pr->queue_size++;
   /* was the request queue previously empty? */
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmission request added to queue\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmission request added to queue\n");
 #endif
-  if ( (pr->pending_head == th)  &&
-       (pr->ntr_task == GNUNET_SCHEDULER_NO_TASK) &&
-       (pr->next == NULL) &&
-       (pr->prev == NULL) &&
-       (handle->ready_peer_head != pr) )
-    pr->ntr_task = GNUNET_SCHEDULER_add_now (&run_request_next_transmission, pr);
+  if ((pr->pending_head == th) &&
+      (pr->ntr_task == GNUNET_SCHEDULER_NO_TASK) &&
+      (pr->next == NULL) &&
+      (pr->prev == NULL) && (handle->ready_peer_head != pr))
+    pr->ntr_task =
+        GNUNET_SCHEDULER_add_now (&run_request_next_transmission, pr);
   return th;
 }
 
@@ -1685,42 +1599,34 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
  * @param th handle that was returned by "notify_transmit_ready".
  */
 void
-GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle
-                                          *th)
+GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle *th)
 {
   struct PeerRecord *pr = th->peer;
   struct GNUNET_CORE_Handle *h = pr->ch;
   int was_head;
 
   was_head = (pr->pending_head == th);
-  GNUNET_CONTAINER_DLL_remove (pr->pending_head,
-                               pr->pending_tail,
-                               th);    
+  GNUNET_CONTAINER_DLL_remove (pr->pending_head, pr->pending_tail, th);
   pr->queue_size--;
   if (th->cm != NULL)
-    {
-      /* we're currently in the control queue, remove */
-      GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
-                                   h->control_pending_tail,
-                                   th->cm);
-      GNUNET_free (th->cm);      
-    }
+  {
+    /* we're currently in the control queue, remove */
+    GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
+                                 h->control_pending_tail, th->cm);
+    GNUNET_free (th->cm);
+  }
   GNUNET_free (th);
   if (was_head)
+  {
+    if ((pr->prev != NULL) || (pr->next != NULL) || (pr == h->ready_peer_head))
     {
-      if ( (pr->prev != NULL) ||
-           (pr->next != NULL) ||
-           (pr == h->ready_peer_head) )
-        {
-          /* the request that was 'approved' by core was
-             canceled before it could be transmitted; remove
-             us from the 'ready' list */
-          GNUNET_CONTAINER_DLL_remove (h->ready_peer_head,
-                                       h->ready_peer_tail,
-                                       pr);
-        }
-      request_next_transmission (pr);
+      /* the request that was 'approved' by core was
+       * canceled before it could be transmitted; remove
+       * us from the 'ready' list */
+      GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
     }
+    request_next_transmission (pr);
+  }
 }
 
 
@@ -1766,13 +1672,12 @@ struct GNUNET_CORE_PeerRequestHandle
  * @param success was the request transmitted?
  */
 static void
-peer_request_connect_cont (void *cls,
-                           int success)
+peer_request_connect_cont (void *cls, int success)
 {
   struct GNUNET_CORE_PeerRequestHandle *ret = cls;
-  
+
   if (ret->cont != NULL)
-    ret->cont (ret->cont_cls, success);    
+    ret->cont (ret->cont_cls, success);
   GNUNET_free (ret);
 }
 
@@ -1798,34 +1703,31 @@ peer_request_connect_cont (void *cls,
  */
 struct GNUNET_CORE_PeerRequestHandle *
 GNUNET_CORE_peer_request_connect (struct GNUNET_CORE_Handle *h,
-                                  const struct GNUNET_PeerIdentity * peer,
-                                  GNUNET_CORE_ControlContinuation cont,
-                                  void *cont_cls)
+                                  const struct GNUNET_PeerIdentity *peer,
+                                  GNUNET_CORE_ControlContinuation cont,
+                                  void *cont_cls)
 {
   struct GNUNET_CORE_PeerRequestHandle *ret;
   struct ControlMessage *cm;
   struct ConnectMessage *msg;
 
-  if (NULL != GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                                 &peer->hashPubKey))
-    {
+  if (NULL != GNUNET_CONTAINER_multihashmap_get (h->peers, &peer->hashPubKey))
+  {
 #if DEBUG_CORE
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 
-                 "Peers are already connected!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers are already connected!\n");
 #endif
-      return NULL;
-    }
-  
-  cm = GNUNET_malloc (sizeof (struct ControlMessage) + 
-                      sizeof (struct ConnectMessage));
-  msg = (struct ConnectMessage*) &cm[1];
+    return NULL;
+  }
+
+  cm = GNUNET_malloc (sizeof (struct ControlMessage) +
+                      sizeof (struct ConnectMessage));
+  msg = (struct ConnectMessage *) &cm[1];
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_REQUEST_CONNECT);
   msg->header.size = htons (sizeof (struct ConnectMessage));
   msg->reserved = htonl (0);
   msg->peer = *peer;
   GNUNET_CONTAINER_DLL_insert_tail (h->control_pending_head,
-                                    h->control_pending_tail,
-                                    cm);
+                                    h->control_pending_tail, cm);
   ret = GNUNET_malloc (sizeof (struct GNUNET_CORE_PeerRequestHandle));
   ret->h = h;
   ret->cm = cm;
@@ -1834,8 +1736,7 @@ GNUNET_CORE_peer_request_connect (struct GNUNET_CORE_Handle *h,
   cm->cont = &peer_request_connect_cont;
   cm->cont_cls = ret;
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Queueing REQUEST_CONNECT request\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Queueing REQUEST_CONNECT request\n");
 #endif
   trigger_next_request (h, GNUNET_NO);
   return ret;
@@ -1849,18 +1750,18 @@ GNUNET_CORE_peer_request_connect (struct GNUNET_CORE_Handle *h,
  * @param req request handle that was returned for the original request
  */
 void
-GNUNET_CORE_peer_request_connect_cancel (struct GNUNET_CORE_PeerRequestHandle *req)
+GNUNET_CORE_peer_request_connect_cancel (struct GNUNET_CORE_PeerRequestHandle
+                                         *req)
 {
   struct GNUNET_CORE_Handle *h = req->h;
   struct ControlMessage *cm = req->cm;
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "A CHANGE PREFERENCE request was cancelled!\n");
+              "A CHANGE PREFERENCE request was cancelled!\n");
 #endif
   GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
-                               h->control_pending_tail,
-                               cm);
+                               h->control_pending_tail, cm);
   GNUNET_free (cm);
   GNUNET_free (req);
 }
@@ -1869,9 +1770,9 @@ GNUNET_CORE_peer_request_connect_cancel (struct GNUNET_CORE_PeerRequestHandle *r
 /* ****************** GNUNET_CORE_peer_change_preference ******************** */
 
 
-struct GNUNET_CORE_InformationRequestContext 
+struct GNUNET_CORE_InformationRequestContext
 {
-  
+
   /**
    * Our connection to the service.
    */
@@ -1879,7 +1780,7 @@ struct GNUNET_CORE_InformationRequestContext
 
   /**
    * Link to control message, NULL if CM was sent.
-   */ 
+   */
   struct ControlMessage *cm;
 
   /**
@@ -1896,8 +1797,7 @@ struct GNUNET_CORE_InformationRequestContext
  * @param success were we successful?
  */
 static void
-change_preference_send_continuation (void *cls,
-                                     int success)
+change_preference_send_continuation (void *cls, int success)
 {
   struct GNUNET_CORE_InformationRequestContext *irc = cls;
 
@@ -1931,61 +1831,58 @@ change_preference_send_continuation (void *cls,
  */
 struct GNUNET_CORE_InformationRequestContext *
 GNUNET_CORE_peer_change_preference (struct GNUNET_CORE_Handle *h,
-                                    const struct GNUNET_PeerIdentity *peer,
-                                    struct GNUNET_TIME_Relative timeout,
-                                    struct GNUNET_BANDWIDTH_Value32NBO bw_out,
-                                    int32_t amount,
-                                    uint64_t preference,
-                                    GNUNET_CORE_PeerConfigurationInfoCallback info,
-                                    void *info_cls)
+                                    const struct GNUNET_PeerIdentity *peer,
+                                    struct GNUNET_TIME_Relative timeout,
+                                    struct GNUNET_BANDWIDTH_Value32NBO bw_out,
+                                    int32_t amount,
+                                    uint64_t preference,
+                                    GNUNET_CORE_PeerConfigurationInfoCallback
+                                    info, void *info_cls)
 {
   struct GNUNET_CORE_InformationRequestContext *irc;
   struct PeerRecord *pr;
   struct RequestInfoMessage *rim;
   struct ControlMessage *cm;
 
-  pr = GNUNET_CONTAINER_multihashmap_get (h->peers,
-                                          &peer->hashPubKey);
+  pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &peer->hashPubKey);
   if (NULL == pr)
-    {
-      /* attempt to change preference on peer that is not connected */
-      GNUNET_assert (0);
-      return NULL;
-    }
+  {
+    /* attempt to change preference on peer that is not connected */
+    GNUNET_assert (0);
+    return NULL;
+  }
   if (pr->pcic != NULL)
-    {
-      /* second change before first one is done */
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+    /* second change before first one is done */
+    GNUNET_break (0);
+    return NULL;
+  }
   irc = GNUNET_malloc (sizeof (struct GNUNET_CORE_InformationRequestContext));
   irc->h = h;
   irc->pr = pr;
   cm = GNUNET_malloc (sizeof (struct ControlMessage) +
-                      sizeof (struct RequestInfoMessage));
+                      sizeof (struct RequestInfoMessage));
   cm->cont = &change_preference_send_continuation;
   cm->cont_cls = irc;
   irc->cm = cm;
-  rim = (struct RequestInfoMessage*) &cm[1];
+  rim = (struct RequestInfoMessage *) &cm[1];
   rim->header.size = htons (sizeof (struct RequestInfoMessage));
   rim->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_REQUEST_INFO);
   rim->rim_id = htonl (pr->rim_id = h->rim_id_gen++);
   rim->limit_outbound = bw_out;
   rim->reserve_inbound = htonl (amount);
-  rim->preference_change = GNUNET_htonll(preference);
+  rim->preference_change = GNUNET_htonll (preference);
   rim->peer = *peer;
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Queueing CHANGE PREFERENCE request for peer `%s' with RIM %u\n",
-              GNUNET_i2s (peer),
-              (unsigned int) pr->rim_id);
+              "Queueing CHANGE PREFERENCE request for peer `%s' with RIM %u\n",
+              GNUNET_i2s (peer), (unsigned int) pr->rim_id);
 #endif
   GNUNET_CONTAINER_DLL_insert_tail (h->control_pending_head,
-                                    h->control_pending_tail,
-                                    cm); 
+                                    h->control_pending_tail, cm);
   pr->pcic = info;
   pr->pcic_cls = info_cls;
-  pr->pcic_ptr = irc; /* for free'ing irc */
+  pr->pcic_ptr = irc;           /* for free'ing irc */
   if (NULL != h->client)
     trigger_next_request (h, GNUNET_NO);
   return irc;
@@ -2004,19 +1901,20 @@ GNUNET_CORE_peer_change_preference (struct GNUNET_CORE_Handle *h,
  * @param irc context returned by the original GNUNET_CORE_peer_get_info call
  */
 void
-GNUNET_CORE_peer_change_preference_cancel (struct GNUNET_CORE_InformationRequestContext *irc)
+GNUNET_CORE_peer_change_preference_cancel (struct
+                                           GNUNET_CORE_InformationRequestContext
+                                           *irc)
 {
   struct GNUNET_CORE_Handle *h = irc->h;
   struct PeerRecord *pr = irc->pr;
 
   GNUNET_assert (pr->pcic_ptr == irc);
   if (irc->cm != NULL)
-    {
-      GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
-                                   h->control_pending_tail,
-                                   irc->cm);
-      GNUNET_free (irc->cm);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
+                                 h->control_pending_tail, irc->cm);
+    GNUNET_free (irc->cm);
+  }
   pr->pcic = NULL;
   pr->pcic_cls = NULL;
   pr->pcic_ptr = NULL;
diff --git a/src/core/core_api_iterate_peers.c b/src/core/core_api_iterate_peers.c
index 967580f83..1bad9a768 100644
--- a/src/core/core_api_iterate_peers.c
+++ b/src/core/core_api_iterate_peers.c
@@ -66,8 +66,7 @@ struct GNUNET_CORE_RequestContext
  * @param msg NULL on error or last entry
  */
 static void
-receive_info (void *cls,
-              const struct GNUNET_MessageHeader *msg)
+receive_info (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_CORE_RequestContext *request_context = cls;
   const struct ConnectNotifyMessage *connect_message;
@@ -75,53 +74,51 @@ receive_info (void *cls,
   uint16_t msize;
 
   /* Handle last message or error case, disconnect and clean up */
-  if ( (msg == NULL) ||
+  if ((msg == NULL) ||
       ((ntohs (msg->type) == GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS_END) &&
-      (ntohs (msg->size) == sizeof (struct GNUNET_MessageHeader))) )
-    {
-      if (request_context->peer_cb != NULL)
-        request_context->peer_cb (request_context->cb_cls,
-                                  NULL, NULL);
-      GNUNET_CLIENT_disconnect (request_context->client, GNUNET_NO);
-      GNUNET_free (request_context);
-      return;
-    }
+       (ntohs (msg->size) == sizeof (struct GNUNET_MessageHeader))))
+  {
+    if (request_context->peer_cb != NULL)
+      request_context->peer_cb (request_context->cb_cls, NULL, NULL);
+    GNUNET_CLIENT_disconnect (request_context->client, GNUNET_NO);
+    GNUNET_free (request_context);
+    return;
+  }
 
   msize = ntohs (msg->size);
   /* Handle incorrect message type or size, disconnect and clean up */
-  if ( (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT) ||
-       (msize < sizeof (struct ConnectNotifyMessage)) )
-    {
-      GNUNET_break (0);
-      if (request_context->peer_cb != NULL)
-        request_context->peer_cb (request_context->cb_cls,
-                                  NULL, NULL);
-      GNUNET_CLIENT_disconnect (request_context->client, GNUNET_NO);
-      GNUNET_free (request_context);
-      return;
-    }
+  if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT) ||
+      (msize < sizeof (struct ConnectNotifyMessage)))
+  {
+    GNUNET_break (0);
+    if (request_context->peer_cb != NULL)
+      request_context->peer_cb (request_context->cb_cls, NULL, NULL);
+    GNUNET_CLIENT_disconnect (request_context->client, GNUNET_NO);
+    GNUNET_free (request_context);
+    return;
+  }
   connect_message = (const struct ConnectNotifyMessage *) msg;
   ats_count = ntohl (connect_message->ats_count);
-  if ( (msize != sizeof (struct ConnectNotifyMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) ||
-       (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR != ntohl ((&connect_message->ats)[ats_count].type)) )
-    {
-      GNUNET_break (0);
-      if (request_context->peer_cb != NULL)
-        request_context->peer_cb (request_context->cb_cls,
-                                  NULL, NULL);
-      GNUNET_CLIENT_disconnect (request_context->client, GNUNET_NO);
-      GNUNET_free (request_context);
-      return;
-    }
+  if ((msize !=
+       sizeof (struct ConnectNotifyMessage) +
+       ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)) ||
+      (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR !=
+       ntohl ((&connect_message->ats)[ats_count].type)))
+  {
+    GNUNET_break (0);
+    if (request_context->peer_cb != NULL)
+      request_context->peer_cb (request_context->cb_cls, NULL, NULL);
+    GNUNET_CLIENT_disconnect (request_context->client, GNUNET_NO);
+    GNUNET_free (request_context);
+    return;
+  }
   /* Normal case */
   if (request_context->peer_cb != NULL)
     request_context->peer_cb (request_context->cb_cls,
-                              &connect_message->peer,
-                              &connect_message->ats);
-  GNUNET_CLIENT_receive(request_context->client, 
-                        &receive_info, 
-                        request_context,
-                        GNUNET_TIME_UNIT_FOREVER_REL);
+                              &connect_message->peer, &connect_message->ats);
+  GNUNET_CLIENT_receive (request_context->client,
+                         &receive_info,
+                         request_context, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 /**
@@ -136,28 +133,29 @@ receive_info (void *cls,
  * @return number of bytes written to buf
  */
 static size_t
-transmit_request(void *cls,
-                 size_t size, void *buf)
+transmit_request (void *cls, size_t size, void *buf)
 {
   struct GNUNET_MessageHeader *msg;
   struct GNUNET_PeerIdentity *peer = cls;
   int msize;
 
   if (peer == NULL)
-    msize = sizeof(struct GNUNET_MessageHeader);
+    msize = sizeof (struct GNUNET_MessageHeader);
   else
-    msize = sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_PeerIdentity);
+    msize =
+        sizeof (struct GNUNET_MessageHeader) +
+        sizeof (struct GNUNET_PeerIdentity);
 
   if ((size < msize) || (buf == NULL))
     return 0;
 
-  msg = (struct GNUNET_MessageHeader *)buf;
+  msg = (struct GNUNET_MessageHeader *) buf;
   msg->size = htons (msize);
   if (peer != NULL)
-    {
-      msg->type = htons (GNUNET_MESSAGE_TYPE_CORE_PEER_CONNECTED);
-      memcpy(&msg[1], peer, sizeof(struct GNUNET_PeerIdentity));
-    }
+  {
+    msg->type = htons (GNUNET_MESSAGE_TYPE_CORE_PEER_CONNECTED);
+    memcpy (&msg[1], peer, sizeof (struct GNUNET_PeerIdentity));
+  }
   else
     msg->type = htons (GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS);
 
@@ -189,21 +187,26 @@ GNUNET_CORE_is_peer_connected (const struct GNUNET_CONFIGURATION_Handle *cfg,
   client = GNUNET_CLIENT_connect ("core", cfg);
   if (client == NULL)
     return GNUNET_SYSERR;
-  GNUNET_assert(peer != NULL);
+  GNUNET_assert (peer != NULL);
   request_context = GNUNET_malloc (sizeof (struct GNUNET_CORE_RequestContext));
   request_context->client = client;
   request_context->peer_cb = peer_cb;
   request_context->cb_cls = cb_cls;
   request_context->peer = peer;
 
-  request_context->th = GNUNET_CLIENT_notify_transmit_ready(client,
-                                                            sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_PeerIdentity),
-                                                            GNUNET_TIME_relative_get_forever(),
-                                                            GNUNET_YES,
-                                                            &transmit_request,
-                                                            peer);
-  GNUNET_assert(request_context->th != NULL);
-  GNUNET_CLIENT_receive(client, &receive_info, request_context, GNUNET_TIME_relative_get_forever());
+  request_context->th = GNUNET_CLIENT_notify_transmit_ready (client,
+                                                             sizeof (struct
+                                                                     GNUNET_MessageHeader)
+                                                             +
+                                                             sizeof (struct
+                                                                     GNUNET_PeerIdentity),
+                                                             GNUNET_TIME_relative_get_forever
+                                                             (), GNUNET_YES,
+                                                             &transmit_request,
+                                                             peer);
+  GNUNET_assert (request_context->th != NULL);
+  GNUNET_CLIENT_receive (client, &receive_info, request_context,
+                         GNUNET_TIME_relative_get_forever ());
   return GNUNET_OK;
 }
 
@@ -235,14 +238,16 @@ GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
   request_context->peer_cb = peer_cb;
   request_context->cb_cls = cb_cls;
 
-  request_context->th = GNUNET_CLIENT_notify_transmit_ready(client,
-                                                            sizeof(struct GNUNET_MessageHeader),
-                                                            GNUNET_TIME_relative_get_forever(),
-                                                            GNUNET_YES,
-                                                            &transmit_request,
-                                                            NULL);
+  request_context->th = GNUNET_CLIENT_notify_transmit_ready (client,
+                                                             sizeof (struct
+                                                                     GNUNET_MessageHeader),
+                                                             GNUNET_TIME_relative_get_forever
+                                                             (), GNUNET_YES,
+                                                             &transmit_request,
+                                                             NULL);
 
-  GNUNET_CLIENT_receive(client, &receive_info, request_context, GNUNET_TIME_relative_get_forever());
+  GNUNET_CLIENT_receive (client, &receive_info, request_context,
+                         GNUNET_TIME_relative_get_forever ());
   return GNUNET_OK;
 }
 
diff --git a/src/core/gnunet-core-list-connections.c b/src/core/gnunet-core-list-connections.c
index 8b0f6773a..284a79f69 100644
--- a/src/core/gnunet-core-list-connections.c
+++ b/src/core/gnunet-core-list-connections.c
@@ -36,7 +36,7 @@
 static int no_resolve;
 
 #if VERBOSE
-  static unsigned int peer_count;
+static unsigned int peer_count;
 #endif
 
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -74,15 +74,15 @@ dump_pc (struct PrintContext *pc)
   struct AddressStringList *address;
 
   GNUNET_CRYPTO_hash_to_enc (&pc->peer.hashPubKey, &enc);
-  printf (_("Peer `%s'\n"),
-          (const char *) &enc);
+  printf (_("Peer `%s'\n"), (const char *) &enc);
   while (NULL != (address = pc->address_list_head))
-    {
-      printf ("\t%s\n", address->address_string);
-      GNUNET_free(address->address_string);
-      GNUNET_CONTAINER_DLL_remove(pc->address_list_head, pc->address_list_tail, address);
-      GNUNET_free(address);
-    }
+  {
+    printf ("\t%s\n", address->address_string);
+    GNUNET_free (address->address_string);
+    GNUNET_CONTAINER_DLL_remove (pc->address_list_head, pc->address_list_tail,
+                                 address);
+    GNUNET_free (address);
+  }
 
   printf ("\n");
 
@@ -97,24 +97,24 @@ dump_pc (struct PrintContext *pc)
  * @param address NULL on error, otherwise 0-terminated printable UTF-8 string
  */
 static void
-process_resolved_address (void *cls,
-                          const char *address)
+process_resolved_address (void *cls, const char *address)
 {
   struct PrintContext *pc = cls;
   struct AddressStringList *new_address;
 
   if (address == NULL)
-    {
-      dump_pc (pc);
-      return;
-    }
+  {
+    dump_pc (pc);
+    return;
+  }
 
-  new_address = GNUNET_malloc(sizeof(struct AddressStringList));
+  new_address = GNUNET_malloc (sizeof (struct AddressStringList));
 #if VERBOSE
-  fprintf(stderr, "Received address %s\n", address);
+  fprintf (stderr, "Received address %s\n", address);
 #endif
-  new_address->address_string = GNUNET_strdup(address);
-  GNUNET_CONTAINER_DLL_insert(pc->address_list_head, pc->address_list_tail, new_address);
+  new_address->address_string = GNUNET_strdup (address);
+  GNUNET_CONTAINER_DLL_insert (pc->address_list_head, pc->address_list_tail,
+                               new_address);
 }
 
 
@@ -127,23 +127,23 @@ connected_peer_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
 {
   struct PrintContext *pc;
 
-  if (peer != NULL) /* Not yet finished */
-    {
+  if (peer != NULL)             /* Not yet finished */
+  {
 #if VERBOSE
-      fprintf(stderr, "Learned about peer %s\n", GNUNET_i2s(peer));
-      peer_count++;
+    fprintf (stderr, "Learned about peer %s\n", GNUNET_i2s (peer));
+    peer_count++;
 #endif
-      pc = GNUNET_malloc (sizeof (struct PrintContext));
-      pc->peer = *peer;
-      GNUNET_TRANSPORT_peer_address_lookup (cfg, peer,
-                                            GNUNET_TIME_UNIT_MINUTES,
-                                            &process_resolved_address, pc);
-    }
+    pc = GNUNET_malloc (sizeof (struct PrintContext));
+    pc->peer = *peer;
+    GNUNET_TRANSPORT_peer_address_lookup (cfg, peer,
+                                          GNUNET_TIME_UNIT_MINUTES,
+                                          &process_resolved_address, pc);
+  }
 #if VERBOSE
   else
-    {
-      fprintf(stderr, "Counted %u total connected peers.\n", peer_count);
-    }
+  {
+    fprintf (stderr, "Counted %u total connected peers.\n", peer_count);
+  }
 #endif
 }
 
@@ -159,22 +159,17 @@ connected_peer_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
 
   cfg = c;
   if (args[0] != NULL)
-    {
-      fprintf (stderr,
-               _("Invalid command line argument `%s'\n"),
-               args[0]);
-      return;
-    }
+  {
+    fprintf (stderr, _("Invalid command line argument `%s'\n"), args[0]);
+    return;
+  }
 
-  GNUNET_CORE_iterate_peers (cfg,
-                             &connected_peer_callback,
-                             NULL);
+  GNUNET_CORE_iterate_peers (cfg, &connected_peer_callback, NULL);
 
 }
 
@@ -199,7 +194,8 @@ main (int argc, char *const *argv)
           GNUNET_PROGRAM_run (argc,
                               argv,
                               "gnunet-list-connections",
-                              gettext_noop ("Print information about connected peers."),
+                              gettext_noop
+                              ("Print information about connected peers."),
                               options, &run, NULL)) ? 0 : 1;
 }
 
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c
index 2e68571a4..95e182448 100644
--- a/src/core/gnunet-service-core.c
+++ b/src/core/gnunet-service-core.c
@@ -164,7 +164,7 @@ enum PeerStateMachine
    * We've sent our session key.
    */
   PEER_STATE_KEY_SENT,
-  
+
   /**
    * We've received the other peers session key.
    */
@@ -241,7 +241,7 @@ struct PingMessage
    * Message type is CORE_PING.
    */
   struct GNUNET_MessageHeader header;
-  
+
   /**
    * Seed for the IV
    */
@@ -271,7 +271,7 @@ struct PongMessage
    * Message type is CORE_PONG.
    */
   struct GNUNET_MessageHeader header;
-    
+
   /**
    * Seed for the IV
    */
@@ -489,7 +489,7 @@ struct Neighbour
 
   /**
    * Performance data for the peer.
-   */ 
+   */
   struct GNUNET_TRANSPORT_ATS_Information *ats;
 
   /**
@@ -578,7 +578,7 @@ struct Neighbour
 
   /**
    * Number of entries in 'ats'.
-   */ 
+   */
   unsigned int ats_count;
 
   /**
@@ -601,12 +601,12 @@ struct Neighbour
   /**
    * Available bandwidth in for this peer (current target).
    */
-  struct GNUNET_BANDWIDTH_Value32NBO bw_in;    
+  struct GNUNET_BANDWIDTH_Value32NBO bw_in;
 
   /**
    * Available bandwidth out for this peer (current target).
    */
-  struct GNUNET_BANDWIDTH_Value32NBO bw_out;  
+  struct GNUNET_BANDWIDTH_Value32NBO bw_out;
 
   /**
    * Internal bandwidth limit set for this peer (initially typically
@@ -634,7 +634,7 @@ struct Neighbour
 
   /**
    * Are we currently connected to this neighbour?
-   */ 
+   */
   int is_connected;
 
 };
@@ -731,7 +731,7 @@ struct ClientActiveRequest
    * Unique request ID (in big endian).
    */
   uint16_t smr_id;
-  
+
 };
 
 
@@ -754,7 +754,7 @@ static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
 /**
  * Bitmap of message types this peer is able to handle.
  */
-static uint32_t my_type_map[(UINT16_MAX + 1)/32];
+static uint32_t my_type_map[(UINT16_MAX + 1) / 32];
 
 /**
  * Handle to peerinfo service.
@@ -821,9 +821,8 @@ static unsigned long long bandwidth_target_out_bps;
  */
 static void
 derive_auth_key (struct GNUNET_CRYPTO_AuthKey *akey,
-    const struct GNUNET_CRYPTO_AesSessionKey *skey,
-    uint32_t seed,
-    struct GNUNET_TIME_Absolute creation_time)
+                 const struct GNUNET_CRYPTO_AesSessionKey *skey,
+                 uint32_t seed, struct GNUNET_TIME_Absolute creation_time)
 {
   static const char ctx[] = "authentication key";
   struct GNUNET_TIME_AbsoluteNBO ctbe;
@@ -833,13 +832,10 @@ derive_auth_key (struct GNUNET_CRYPTO_AuthKey *akey,
   GNUNET_CRYPTO_hmac_derive_key (akey,
                                  skey,
                                  &seed,
-                                 sizeof(seed),
+                                 sizeof (seed),
                                  &skey->key,
-                                 sizeof(skey->key),
-                                 &ctbe,
-                                 sizeof(ctbe),
-                                 ctx,
-                                 sizeof(ctx), NULL);
+                                 sizeof (skey->key),
+                                 &ctbe, sizeof (ctbe), ctx, sizeof (ctx), NULL);
 }
 
 
@@ -848,19 +844,18 @@ derive_auth_key (struct GNUNET_CRYPTO_AuthKey *akey,
  */
 static void
 derive_iv (struct GNUNET_CRYPTO_AesInitializationVector *iv,
-    const struct GNUNET_CRYPTO_AesSessionKey *skey, uint32_t seed,
-    const struct GNUNET_PeerIdentity *identity)
+           const struct GNUNET_CRYPTO_AesSessionKey *skey, uint32_t seed,
+           const struct GNUNET_PeerIdentity *identity)
 {
   static const char ctx[] = "initialization vector";
 
   GNUNET_CRYPTO_aes_derive_iv (iv,
                                skey,
                                &seed,
-                               sizeof(seed),
+                               sizeof (seed),
                                &identity->hashPubKey.bits,
-                               sizeof(identity->hashPubKey.bits),
-                               ctx,
-                               sizeof(ctx), NULL);
+                               sizeof (identity->hashPubKey.bits),
+                               ctx, sizeof (ctx), NULL);
 }
 
 /**
@@ -868,21 +863,19 @@ derive_iv (struct GNUNET_CRYPTO_AesInitializationVector *iv,
  */
 static void
 derive_pong_iv (struct GNUNET_CRYPTO_AesInitializationVector *iv,
-    const struct GNUNET_CRYPTO_AesSessionKey *skey, uint32_t seed,
-    uint32_t challenge, const struct GNUNET_PeerIdentity *identity)
+                const struct GNUNET_CRYPTO_AesSessionKey *skey, uint32_t seed,
+                uint32_t challenge, const struct GNUNET_PeerIdentity *identity)
 {
   static const char ctx[] = "pong initialization vector";
 
   GNUNET_CRYPTO_aes_derive_iv (iv,
                                skey,
                                &seed,
-                               sizeof(seed),
+                               sizeof (seed),
                                &identity->hashPubKey.bits,
-                               sizeof(identity->hashPubKey.bits),
+                               sizeof (identity->hashPubKey.bits),
                                &challenge,
-                               sizeof(challenge),
-                               ctx,
-                               sizeof(ctx), NULL);
+                               sizeof (challenge), ctx, sizeof (ctx), NULL);
 }
 
 
@@ -893,11 +886,11 @@ derive_pong_iv (struct GNUNET_CRYPTO_AesInitializationVector *iv,
  * @param n neighbour in question
  * @return absolute timeout
  */
-static struct GNUNET_TIME_Absolute 
+static struct GNUNET_TIME_Absolute
 get_neighbour_timeout (struct Neighbour *n)
 {
   return GNUNET_TIME_absolute_add (n->last_activity,
-                                   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+                                   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
 }
 
 
@@ -905,9 +898,7 @@ get_neighbour_timeout (struct Neighbour *n)
  * Helper function for update_preference_sum.
  */
 static int
-update_preference (void *cls,
-                   const GNUNET_HashCode *key,
-                   void *value)
+update_preference (void *cls, const GNUNET_HashCode * key, void *value)
 {
   unsigned long long *ps = cls;
   struct Neighbour *n = value;
@@ -915,7 +906,7 @@ update_preference (void *cls,
   n->current_preference /= 2;
   *ps += n->current_preference;
   return GNUNET_OK;
-}    
+}
 
 
 /**
@@ -932,13 +923,13 @@ update_preference_sum (unsigned long long inc)
   os = preference_sum;
   preference_sum += inc;
   if (preference_sum >= os)
-    return; /* done! */
+    return;                     /* done! */
   /* overflow! compensate by cutting all values in half! */
   preference_sum = 0;
   GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &update_preference,
-                                         &preference_sum);
-  GNUNET_STATISTICS_set (stats, gettext_noop ("# total peer preference"), preference_sum, GNUNET_NO);
+                                         &update_preference, &preference_sum);
+  GNUNET_STATISTICS_set (stats, gettext_noop ("# total peer preference"),
+                         preference_sum, GNUNET_NO);
 }
 
 
@@ -966,19 +957,17 @@ find_neighbour (const struct GNUNET_PeerIdentity *peer)
  */
 static void
 send_to_client (struct Client *client,
-                const struct GNUNET_MessageHeader *msg, 
-                int can_drop)
+                const struct GNUNET_MessageHeader *msg, int can_drop)
 {
-#if DEBUG_CORE_CLIENT 
+#if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Preparing to send %u bytes of message of type %u to client.\n",
-              (unsigned int) ntohs (msg->size),
+              (unsigned int) ntohs (msg->size),
               (unsigned int) ntohs (msg->type));
-#endif  
+#endif
   GNUNET_SERVER_notification_context_unicast (notifier,
-                                              client->client_handle,
-                                              msg,
-                                              can_drop);
+                                              client->client_handle,
+                                              msg, can_drop);
 }
 
 
@@ -991,26 +980,25 @@ send_to_client (struct Client *client,
  * @param options mask to use 
  */
 static void
-send_to_all_clients (const struct GNUNET_MessageHeader *msg, 
-                     int can_drop,
-                     int options)
+send_to_all_clients (const struct GNUNET_MessageHeader *msg,
+                     int can_drop, int options)
 {
   struct Client *c;
 
   c = clients;
   while (c != NULL)
+  {
+    if (0 != (c->options & options))
     {
-      if (0 != (c->options & options))
-        {
 #if DEBUG_CORE_CLIENT > 1
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Sending message of type %u to client.\n",
-                      (unsigned int) ntohs (msg->type));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending message of type %u to client.\n",
+                  (unsigned int) ntohs (msg->type));
 #endif
-          send_to_client (c, msg, can_drop);
-        }
-      c = c->next;
+      send_to_client (c, msg, can_drop);
     }
+    c = c->next;
+  }
 }
 
 
@@ -1028,27 +1016,23 @@ handle_peer_status_change (struct Neighbour *n)
   struct GNUNET_TRANSPORT_ATS_Information *ats;
   size_t size;
 
-  if ( (! n->is_connected) ||
-       (n->status != PEER_STATE_KEY_CONFIRMED) )
+  if ((!n->is_connected) || (n->status != PEER_STATE_KEY_CONFIRMED))
     return;
 #if DEBUG_CORE > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' changed status\n",
-              GNUNET_i2s (&n->peer));
+              "Peer `%4s' changed status\n", GNUNET_i2s (&n->peer));
 #endif
   size = sizeof (struct PeerStatusNotifyMessage) +
-    n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+      n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
   if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      /* recovery strategy: throw away performance data */
-      GNUNET_array_grow (n->ats,
-                         n->ats_count,
-                         0);
-      size = sizeof (struct PeerStatusNotifyMessage) +
-        n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
-    }
-  psnm = (struct PeerStatusNotifyMessage*) buf;
+  {
+    GNUNET_break (0);
+    /* recovery strategy: throw away performance data */
+    GNUNET_array_grow (n->ats, n->ats_count, 0);
+    size = sizeof (struct PeerStatusNotifyMessage) +
+        n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+  }
+  psnm = (struct PeerStatusNotifyMessage *) buf;
   psnm->header.size = htons (size);
   psnm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_STATUS_CHANGE);
   psnm->timeout = GNUNET_TIME_absolute_hton (get_neighbour_timeout (n));
@@ -1058,17 +1042,15 @@ handle_peer_status_change (struct Neighbour *n)
   psnm->ats_count = htonl (n->ats_count);
   ats = &psnm->ats;
   memcpy (ats,
-          n->ats,
-          n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
+          n->ats,
+          n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
   ats[n->ats_count].type = htonl (0);
   ats[n->ats_count].value = htonl (0);
-  send_to_all_clients (&psnm->header, 
-                       GNUNET_YES, 
-                       GNUNET_CORE_OPTION_SEND_STATUS_CHANGE);
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# peer status changes"), 
-                            1, 
-                            GNUNET_NO);
+  send_to_all_clients (&psnm->header,
+                       GNUNET_YES, GNUNET_CORE_OPTION_SEND_STATUS_CHANGE);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# peer status changes"),
+                            1, GNUNET_NO);
 }
 
 
@@ -1088,55 +1070,53 @@ schedule_peer_messages (struct Neighbour *n)
   struct Client *c;
   struct MessageEntry *mqe;
   unsigned int queue_size;
-  
+
   /* check if neighbour queue is empty enough! */
   if (n != &self)
+  {
+    queue_size = 0;
+    mqe = n->messages;
+    while (mqe != NULL)
+    {
+      queue_size++;
+      mqe = mqe->next;
+    }
+    if (queue_size >= MAX_PEER_QUEUE_SIZE)
     {
-      queue_size = 0;
-      mqe = n->messages;
-      while (mqe != NULL) 
-        {
-          queue_size++;
-          mqe = mqe->next;
-        }
-      if (queue_size >= MAX_PEER_QUEUE_SIZE)
-        {
 #if DEBUG_CORE_CLIENT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Not considering client transmission requests: queue full\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Not considering client transmission requests: queue full\n");
 #endif
-          return; /* queue still full */
-        }
-      /* find highest priority request */
-      pos = n->active_client_request_head;
-      car = NULL;
-      while (pos != NULL)
-        {
-          if ( (car == NULL) ||
-               (pos->priority > car->priority) )
-            car = pos;
-          pos = pos->next;
-        }
+      return;                   /* queue still full */
     }
-  else
+    /* find highest priority request */
+    pos = n->active_client_request_head;
+    car = NULL;
+    while (pos != NULL)
     {
-      car = n->active_client_request_head;
+      if ((car == NULL) || (pos->priority > car->priority))
+        car = pos;
+      pos = pos->next;
     }
+  }
+  else
+  {
+    car = n->active_client_request_head;
+  }
   if (car == NULL)
-    return; /* no pending requests */
+    return;                     /* no pending requests */
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Permitting client transmission request to `%s'\n",
-              GNUNET_i2s (&n->peer));
+              "Permitting client transmission request to `%s'\n",
+              GNUNET_i2s (&n->peer));
 #endif
   c = car->client;
   GNUNET_CONTAINER_DLL_remove (n->active_client_request_head,
-                               n->active_client_request_tail,
-                               car);
+                               n->active_client_request_tail, car);
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (c->requests,
-                                                       &n->peer.hashPubKey,
-                                                       car));  
+                 GNUNET_CONTAINER_multihashmap_remove (c->requests,
+                                                       &n->peer.hashPubKey,
+                                                       car));
   smr.header.size = htons (sizeof (struct SendMessageReady));
   smr.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SEND_READY);
   smr.size = htons (car->msize);
@@ -1160,27 +1140,28 @@ compute_type_map_message ()
   struct GNUNET_MessageHeader *hdr;
 
 #ifdef compressBound
-  dlen = compressBound (sizeof(my_type_map));
+  dlen = compressBound (sizeof (my_type_map));
 #else
-  dlen = sizeof(my_type_map) + (sizeof(my_type_map) / 100) + 20;
+  dlen = sizeof (my_type_map) + (sizeof (my_type_map) / 100) + 20;
   /* documentation says 100.1% oldSize + 12 bytes, but we
-     should be able to overshoot by more to be safe */
+   * should be able to overshoot by more to be safe */
 #endif
   hdr = GNUNET_malloc (dlen + sizeof (struct GNUNET_MessageHeader));
   hdr->size = htons ((uint16_t) dlen + sizeof (struct GNUNET_MessageHeader));
-  tmp = (char*) &hdr[1];
-  if ( (Z_OK != compress2 ((Bytef *) tmp,
-                           &dlen, (const Bytef *) my_type_map, sizeof (my_type_map), 9)) ||
-       (dlen >= sizeof(my_type_map)) )
-    {
-      dlen = sizeof (my_type_map);
-      memcpy (tmp, my_type_map, sizeof (my_type_map));
-      hdr->type = htons (GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP);
-    }
+  tmp = (char *) &hdr[1];
+  if ((Z_OK != compress2 ((Bytef *) tmp,
+                          &dlen, (const Bytef *) my_type_map,
+                          sizeof (my_type_map), 9)) ||
+      (dlen >= sizeof (my_type_map)))
+  {
+    dlen = sizeof (my_type_map);
+    memcpy (tmp, my_type_map, sizeof (my_type_map));
+    hdr->type = htons (GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP);
+  }
   else
-    {
-      hdr->type = htons (GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP);
-    }
+  {
+    hdr->type = htons (GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP);
+  }
   return hdr;
 }
 
@@ -1194,9 +1175,7 @@ compute_type_map_message ()
  * @return always GNUNET_OK
  */
 static int
-send_type_map_to_neighbour (void *cls,
-                            const GNUNET_HashCode *key,
-                            void *value)
+send_type_map_to_neighbour (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_MessageHeader *hdr = cls;
   struct Neighbour *n = value;
@@ -1225,15 +1204,14 @@ send_type_map_to_neighbour (void *cls,
  */
 static void
 broadcast_my_type_map ()
-{  
+{
   struct GNUNET_MessageHeader *hdr;
 
   if (NULL == neighbours)
     return;
   hdr = compute_type_map_message ();
   GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &send_type_map_to_neighbour,
-                                         hdr);  
+                                         &send_type_map_to_neighbour, hdr);
   GNUNET_free (hdr);
 }
 
@@ -1243,72 +1221,68 @@ broadcast_my_type_map ()
  */
 static void
 handle_client_send_request (void *cls,
-                            struct GNUNET_SERVER_Client *client,
-                            const struct GNUNET_MessageHeader *message)
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message)
 {
   const struct SendMessageRequest *req;
   struct Neighbour *n;
   struct Client *c;
   struct ClientActiveRequest *car;
 
-  req = (const struct SendMessageRequest*) message;
+  req = (const struct SendMessageRequest *) message;
   if (0 == memcmp (&req->peer,
-                   &my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
+                   &my_identity, sizeof (struct GNUNET_PeerIdentity)))
     n = &self;
   else
     n = find_neighbour (&req->peer);
-  if ( (n == NULL) ||
-       (GNUNET_YES != n->is_connected) ||
-       (n->status != PEER_STATE_KEY_CONFIRMED) )
-    { 
-      /* neighbour must have disconnected since request was issued,
-         ignore (client will realize it once it processes the 
-         disconnect notification) */
+  if ((n == NULL) ||
+      (GNUNET_YES != n->is_connected) ||
+      (n->status != PEER_STATE_KEY_CONFIRMED))
+  {
+    /* neighbour must have disconnected since request was issued,
+     * ignore (client will realize it once it processes the 
+     * disconnect notification) */
 #if DEBUG_CORE_CLIENT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Dropped client request for transmission (am disconnected)\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Dropped client request for transmission (am disconnected)\n");
 #endif
-      GNUNET_STATISTICS_update (stats, 
-                                gettext_noop ("# send requests dropped (disconnected)"), 
-                                1, 
-                                GNUNET_NO);
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# send requests dropped (disconnected)"), 1,
+                              GNUNET_NO);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   c = clients;
-  while ( (c != NULL) &&
-          (c->client_handle != client) )
+  while ((c != NULL) && (c->client_handle != client))
     c = c->next;
   if (c == NULL)
-    {
-      /* client did not send INIT first! */
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    /* client did not send INIT first! */
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   if (c->requests == NULL)
     c->requests = GNUNET_CONTAINER_multihashmap_create (16);
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received client transmission request. queueing\n");
 #endif
-  car = GNUNET_CONTAINER_multihashmap_get (c->requests,
-                                           &req->peer.hashPubKey);
+  car = GNUNET_CONTAINER_multihashmap_get (c->requests, &req->peer.hashPubKey);
   if (car == NULL)
-    {
-      /* create new entry */
-      car = GNUNET_malloc (sizeof (struct ClientActiveRequest));
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (c->requests,
-                                                        &req->peer.hashPubKey,
-                                                        car,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
-      GNUNET_CONTAINER_DLL_insert (n->active_client_request_head,
-                                   n->active_client_request_tail,
-                                   car);
-      car->client = c;
-    }
+  {
+    /* create new entry */
+    car = GNUNET_malloc (sizeof (struct ClientActiveRequest));
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (c->requests,
+                                                      &req->peer.hashPubKey,
+                                                      car,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+    GNUNET_CONTAINER_DLL_insert (n->active_client_request_head,
+                                 n->active_client_request_tail, car);
+    car->client = c;
+  }
   car->deadline = GNUNET_TIME_absolute_ntoh (req->deadline);
   car->priority = ntohl (req->priority);
   car->queue_size = ntohl (req->queue_size);
@@ -1324,8 +1298,7 @@ handle_client_send_request (void *cls,
  */
 static int
 notify_client_about_neighbour (void *cls,
-                               const GNUNET_HashCode *key,
-                               void *value)
+                               const GNUNET_HashCode * key, void *value)
 {
   struct Client *c = cls;
   struct Neighbour *n = value;
@@ -1335,36 +1308,34 @@ notify_client_about_neighbour (void *cls,
   struct ConnectNotifyMessage *cnm;
 
   size = sizeof (struct ConnectNotifyMessage) +
-    (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+      (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
   if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      /* recovery strategy: throw away performance data */
-      GNUNET_array_grow (n->ats,
-                         n->ats_count,
-                         0);
-      size = sizeof (struct ConnectNotifyMessage) +
-        (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
-    }
-  cnm = (struct ConnectNotifyMessage*) buf;       
+  {
+    GNUNET_break (0);
+    /* recovery strategy: throw away performance data */
+    GNUNET_array_grow (n->ats, n->ats_count, 0);
+    size = sizeof (struct ConnectNotifyMessage) +
+        (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+  }
+  cnm = (struct ConnectNotifyMessage *) buf;
   cnm->header.size = htons (size);
   cnm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
   cnm->ats_count = htonl (n->ats_count);
   ats = &cnm->ats;
   memcpy (ats,
-          n->ats,
-          sizeof (struct GNUNET_TRANSPORT_ATS_Information) * n->ats_count);
+          n->ats,
+          sizeof (struct GNUNET_TRANSPORT_ATS_Information) * n->ats_count);
   ats[n->ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   ats[n->ats_count].value = htonl (0);
   if (n->status == PEER_STATE_KEY_CONFIRMED)
-    {
+  {
 #if DEBUG_CORE_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending `%s' message to client.\n", "NOTIFY_CONNECT");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending `%s' message to client.\n", "NOTIFY_CONNECT");
 #endif
-      cnm->peer = n->peer;
-      send_to_client (c, &cnm->header, GNUNET_NO);
-    }
+    cnm->peer = n->peer;
+    send_to_client (c, &cnm->header, GNUNET_NO);
+  }
   return GNUNET_OK;
 }
 
@@ -1388,28 +1359,27 @@ handle_client_init (void *cls,
 
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client connecting to core service with `%s' message\n",
-              "INIT");
+              "Client connecting to core service with `%s' message\n", "INIT");
 #endif
   /* check that we don't have an entry already */
   c = clients;
   while (c != NULL)
-    {
-      if (client == c->client_handle)
-        {
-          GNUNET_break (0);
-          GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-          return;
-        }
-      c = c->next;
-    }
-  msize = ntohs (message->size);
-  if (msize < sizeof (struct InitMessage))
+  {
+    if (client == c->client_handle)
     {
       GNUNET_break (0);
       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
       return;
     }
+    c = c->next;
+  }
+  msize = ntohs (message->size);
+  if (msize < sizeof (struct InitMessage))
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   GNUNET_SERVER_notification_context_add (notifier, client);
   im = (const struct InitMessage *) message;
   types = (const uint16_t *) &im[1];
@@ -1420,20 +1390,19 @@ handle_client_init (void *cls,
   clients = c;
   c->tcnt = msize / sizeof (uint16_t);
   c->types = (const uint16_t *) &c[1];
-  wtypes = (uint16_t *) &c[1];
-  for (i=0;i<c->tcnt;i++)
-    {
-      wtypes[i] = ntohs (types[i]);
-      my_type_map[wtypes[i]/32] |= (1 << (wtypes[i] % 32));
-    }
+  wtypes = (uint16_t *) & c[1];
+  for (i = 0; i < c->tcnt; i++)
+  {
+    wtypes[i] = ntohs (types[i]);
+    my_type_map[wtypes[i] / 32] |= (1 << (wtypes[i] % 32));
+  }
   if (c->tcnt > 0)
     broadcast_my_type_map ();
   c->options = ntohl (im->options);
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client %p is interested in %u message types\n",
-              c,
-              (unsigned int) c->tcnt);
+              "Client %p is interested in %u message types\n",
+              c, (unsigned int) c->tcnt);
 #endif
   /* send init reply message */
   irm.header.size = htons (sizeof (struct InitReplyMessage));
@@ -1448,12 +1417,11 @@ handle_client_init (void *cls,
 #endif
   send_to_client (c, &irm.header, GNUNET_NO);
   if (0 != (c->options & GNUNET_CORE_OPTION_SEND_CONNECT))
-    {
-      /* notify new client about existing neighbours */
-      GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                             &notify_client_about_neighbour,
-                                             c);
-    }
+  {
+    /* notify new client about existing neighbours */
+    GNUNET_CONTAINER_multihashmap_iterate (neighbours,
+                                           &notify_client_about_neighbour, c);
+  }
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -1468,8 +1436,7 @@ handle_client_init (void *cls,
  */
 static int
 destroy_active_client_request (void *cls,
-                               const GNUNET_HashCode *key,
-                               void *value)
+                               const GNUNET_HashCode * key, void *value)
 {
   struct ClientActiveRequest *car = value;
   struct Neighbour *n;
@@ -1479,8 +1446,7 @@ destroy_active_client_request (void *cls,
   n = find_neighbour (&peer);
   GNUNET_assert (NULL != n);
   GNUNET_CONTAINER_DLL_remove (n->active_client_request_head,
-                               n->active_client_request_tail,
-                               car);
+                               n->active_client_request_tail, car);
   GNUNET_free (car);
   return GNUNET_YES;
 }
@@ -1504,44 +1470,43 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
     return;
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client %p has disconnected from core service.\n",
-              client);
+              "Client %p has disconnected from core service.\n", client);
 #endif
   prev = NULL;
   pos = clients;
   while (pos != NULL)
-    {
-      if (client == pos->client_handle)
-        break;
-      prev = pos;
-      pos = pos->next;
-    }
+  {
+    if (client == pos->client_handle)
+      break;
+    prev = pos;
+    pos = pos->next;
+  }
   if (pos == NULL)
-    {
-      /* client never sent INIT */
-      return;
-    }
+  {
+    /* client never sent INIT */
+    return;
+  }
   if (prev == NULL)
     clients = pos->next;
   else
     prev->next = pos->next;
   if (pos->requests != NULL)
-    {
-      GNUNET_CONTAINER_multihashmap_iterate (pos->requests,
-                                             &destroy_active_client_request,
-                                             NULL);
-      GNUNET_CONTAINER_multihashmap_destroy (pos->requests);
-    }
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (pos->requests,
+                                           &destroy_active_client_request,
+                                           NULL);
+    GNUNET_CONTAINER_multihashmap_destroy (pos->requests);
+  }
   GNUNET_free (pos);
 
   /* rebuild my_type_map */
   memset (my_type_map, 0, sizeof (my_type_map));
   for (pos = clients; NULL != pos; pos = pos->next)
-    {
-      wtypes = (const uint16_t *) &pos[1];
-      for (i=0;i<pos->tcnt;i++)
-        my_type_map[wtypes[i]/32] |= (1 << (wtypes[i] % 32));
-    }
+  {
+    wtypes = (const uint16_t *) &pos[1];
+    for (i = 0; i < pos->tcnt; i++)
+      my_type_map[wtypes[i] / 32] |= (1 << (wtypes[i] % 32));
+  }
   broadcast_my_type_map ();
 }
 
@@ -1555,9 +1520,7 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-queue_connect_message (void *cls,
-                       const GNUNET_HashCode *key,
-                       void *value)
+queue_connect_message (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_SERVER_TransmitContext *tc = cls;
   struct Neighbour *n = value;
@@ -1566,39 +1529,35 @@ queue_connect_message (void *cls,
   size_t size;
   struct ConnectNotifyMessage *cnm;
 
-  cnm = (struct ConnectNotifyMessage*) buf;
+  cnm = (struct ConnectNotifyMessage *) buf;
   if (n->status != PEER_STATE_KEY_CONFIRMED)
     return GNUNET_OK;
   size = sizeof (struct ConnectNotifyMessage) +
-    (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+      (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
   if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      /* recovery strategy: throw away performance data */
-      GNUNET_array_grow (n->ats,
-                         n->ats_count,
-                         0);
-      size = sizeof (struct PeerStatusNotifyMessage) +
-        n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
-    }
-  cnm = (struct ConnectNotifyMessage*) buf;
+  {
+    GNUNET_break (0);
+    /* recovery strategy: throw away performance data */
+    GNUNET_array_grow (n->ats, n->ats_count, 0);
+    size = sizeof (struct PeerStatusNotifyMessage) +
+        n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+  }
+  cnm = (struct ConnectNotifyMessage *) buf;
   cnm->header.size = htons (size);
   cnm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
   cnm->ats_count = htonl (n->ats_count);
   ats = &cnm->ats;
   memcpy (ats,
-          n->ats,
-          n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
+          n->ats,
+          n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
   ats[n->ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
-  ats[n->ats_count].value = htonl (0);    
+  ats[n->ats_count].value = htonl (0);
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending `%s' message to client.\n",
-              "NOTIFY_CONNECT");
+              "Sending `%s' message to client.\n", "NOTIFY_CONNECT");
 #endif
   cnm->peer = n->peer;
-  GNUNET_SERVER_transmit_context_append_message (tc, 
-                                                 &cnm->header);
+  GNUNET_SERVER_transmit_context_append_message (tc, &cnm->header);
   return GNUNET_OK;
 }
 
@@ -1612,27 +1571,27 @@ queue_connect_message (void *cls,
  */
 static void
 handle_client_iterate_peers (void *cls,
-                             struct GNUNET_SERVER_Client *client,
-                             const struct GNUNET_MessageHeader *message)
-
+                             struct GNUNET_SERVER_Client *client,
+                             const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_MessageHeader done_msg;
   struct GNUNET_SERVER_TransmitContext *tc;
   int msize;
+
   /* notify new client about existing neighbours */
 
-  msize = ntohs(message->size);
+  msize = ntohs (message->size);
   tc = GNUNET_SERVER_transmit_context_create (client);
-  if (msize == sizeof(struct GNUNET_MessageHeader))
-    GNUNET_CONTAINER_multihashmap_iterate (neighbours, &queue_connect_message, tc);
+  if (msize == sizeof (struct GNUNET_MessageHeader))
+    GNUNET_CONTAINER_multihashmap_iterate (neighbours, &queue_connect_message,
+                                           tc);
   else
-    GNUNET_break(0);
+    GNUNET_break (0);
 
   done_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   done_msg.type = htons (GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS_END);
   GNUNET_SERVER_transmit_context_append_message (tc, &done_msg);
-  GNUNET_SERVER_transmit_context_run (tc,
-                                      GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -1645,9 +1604,8 @@ handle_client_iterate_peers (void *cls,
  */
 static void
 handle_client_have_peer (void *cls,
-                             struct GNUNET_SERVER_Client *client,
-                             const struct GNUNET_MessageHeader *message)
-
+                         struct GNUNET_SERVER_Client *client,
+                         const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_MessageHeader done_msg;
   struct GNUNET_SERVER_TransmitContext *tc;
@@ -1655,15 +1613,13 @@ handle_client_have_peer (void *cls,
 
   tc = GNUNET_SERVER_transmit_context_create (client);
   peer = (struct GNUNET_PeerIdentity *) &message[1];
-  GNUNET_CONTAINER_multihashmap_get_multiple(neighbours,
-                                             &peer->hashPubKey, 
-                                             &queue_connect_message, 
-                                             tc);
+  GNUNET_CONTAINER_multihashmap_get_multiple (neighbours,
+                                              &peer->hashPubKey,
+                                              &queue_connect_message, tc);
   done_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   done_msg.type = htons (GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS_END);
   GNUNET_SERVER_transmit_context_append_message (tc, &done_msg);
-  GNUNET_SERVER_transmit_context_run (tc,
-                                      GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -1676,8 +1632,8 @@ handle_client_have_peer (void *cls,
  */
 static void
 handle_client_request_info (void *cls,
-                            struct GNUNET_SERVER_Client *client,
-                            const struct GNUNET_MessageHeader *message)
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message)
 {
   const struct RequestInfoMessage *rcm;
   struct Client *pos;
@@ -1688,97 +1644,94 @@ handle_client_request_info (void *cls,
   unsigned long long old_preference;
   struct GNUNET_TIME_Relative rdelay;
 
-  rdelay = GNUNET_TIME_relative_get_zero();
+  rdelay = GNUNET_TIME_relative_get_zero ();
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core service receives `%s' request.\n", "REQUEST_INFO");
 #endif
   pos = clients;
   while (pos != NULL)
-    {
-      if (client == pos->client_handle)
-        break;
-      pos = pos->next;
-    }
+  {
+    if (client == pos->client_handle)
+      break;
+    pos = pos->next;
+  }
   if (pos == NULL)
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
 
   rcm = (const struct RequestInfoMessage *) message;
   n = find_neighbour (&rcm->peer);
   memset (&cim, 0, sizeof (cim));
-  if ( (n != NULL) && (GNUNET_YES == n->is_connected) )
+  if ((n != NULL) && (GNUNET_YES == n->is_connected))
+  {
+    want_reserv = ntohl (rcm->reserve_inbound);
+    if (n->bw_out_internal_limit.value__ != rcm->limit_outbound.value__)
     {
-      want_reserv = ntohl (rcm->reserve_inbound);
-      if (n->bw_out_internal_limit.value__ != rcm->limit_outbound.value__)
-        {
-          n->bw_out_internal_limit = rcm->limit_outbound;
-          if (n->bw_out.value__ != GNUNET_BANDWIDTH_value_min (n->bw_out_internal_limit,
-                                                               n->bw_out_external_limit).value__)
-            {
-              n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_internal_limit,
-                                                      n->bw_out_external_limit);
-              GNUNET_BANDWIDTH_tracker_update_quota (&n->available_recv_window,
-                                                     n->bw_out);
-              GNUNET_TRANSPORT_set_quota (transport,
-                                          &n->peer,
-                                          n->bw_in,
-                                          n->bw_out);
-              handle_peer_status_change (n);
-            }
-        }
-      if (want_reserv < 0)
-        {
-          got_reserv = want_reserv;
-        }
-      else if (want_reserv > 0)
-        {
-          rdelay = GNUNET_BANDWIDTH_tracker_get_delay (&n->available_recv_window,
-                                                       want_reserv);
-          if (rdelay.rel_value == 0)
-            got_reserv = want_reserv;
-          else
-            got_reserv = 0; /* all or nothing */
-        }
+      n->bw_out_internal_limit = rcm->limit_outbound;
+      if (n->bw_out.value__ !=
+          GNUNET_BANDWIDTH_value_min (n->bw_out_internal_limit,
+                                      n->bw_out_external_limit).value__)
+      {
+        n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_internal_limit,
+                                                n->bw_out_external_limit);
+        GNUNET_BANDWIDTH_tracker_update_quota (&n->available_recv_window,
+                                               n->bw_out);
+        GNUNET_TRANSPORT_set_quota (transport, &n->peer, n->bw_in, n->bw_out);
+        handle_peer_status_change (n);
+      }
+    }
+    if (want_reserv < 0)
+    {
+      got_reserv = want_reserv;
+    }
+    else if (want_reserv > 0)
+    {
+      rdelay = GNUNET_BANDWIDTH_tracker_get_delay (&n->available_recv_window,
+                                                   want_reserv);
+      if (rdelay.rel_value == 0)
+        got_reserv = want_reserv;
       else
-        got_reserv = 0;
-      GNUNET_BANDWIDTH_tracker_consume (&n->available_recv_window,
-                                        got_reserv);
-      old_preference = n->current_preference;
-      n->current_preference += GNUNET_ntohll(rcm->preference_change);
-      if (old_preference > n->current_preference) 
-        {
-          /* overflow; cap at maximum value */
-          n->current_preference = ULLONG_MAX;
-        }
-      update_preference_sum (n->current_preference - old_preference);
-#if DEBUG_CORE_QUOTA 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received reservation request for %d bytes for peer `%4s', reserved %d bytes, suggesting delay of %llu ms\n",
-                  (int) want_reserv,
-                  GNUNET_i2s (&rcm->peer),
-                  (int) got_reserv,
-                  (unsigned long long) rdelay.rel_value);
-#endif
-      cim.reserved_amount = htonl (got_reserv);
-      cim.reserve_delay = GNUNET_TIME_relative_hton (rdelay);
-      cim.bw_out = n->bw_out;
-      cim.preference = n->current_preference;
+        got_reserv = 0;         /* all or nothing */
     }
-  else
+    else
+      got_reserv = 0;
+    GNUNET_BANDWIDTH_tracker_consume (&n->available_recv_window, got_reserv);
+    old_preference = n->current_preference;
+    n->current_preference += GNUNET_ntohll (rcm->preference_change);
+    if (old_preference > n->current_preference)
     {
-      /* Technically, this COULD happen (due to asynchronous behavior),
-         but it should be rare, so we should generate an info event 
-         to help diagnosis of serious errors that might be masked by this */
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Client asked for preference change with peer `%s', which is not connected!\n"),
-                  GNUNET_i2s (&rcm->peer));
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
+      /* overflow; cap at maximum value */
+      n->current_preference = ULLONG_MAX;
     }
+    update_preference_sum (n->current_preference - old_preference);
+#if DEBUG_CORE_QUOTA
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received reservation request for %d bytes for peer `%4s', reserved %d bytes, suggesting delay of %llu ms\n",
+                (int) want_reserv,
+                GNUNET_i2s (&rcm->peer),
+                (int) got_reserv, (unsigned long long) rdelay.rel_value);
+#endif
+    cim.reserved_amount = htonl (got_reserv);
+    cim.reserve_delay = GNUNET_TIME_relative_hton (rdelay);
+    cim.bw_out = n->bw_out;
+    cim.preference = n->current_preference;
+  }
+  else
+  {
+    /* Technically, this COULD happen (due to asynchronous behavior),
+     * but it should be rare, so we should generate an info event 
+     * to help diagnosis of serious errors that might be masked by this */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Client asked for preference change with peer `%s', which is not connected!\n"),
+                GNUNET_i2s (&rcm->peer));
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   cim.header.size = htons (sizeof (struct ConfigurationInfoMessage));
   cim.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO);
   cim.peer = rcm->peer;
@@ -1806,47 +1759,44 @@ free_neighbour (struct Neighbour *n)
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Destroying neighbour entry for peer `%4s'\n",
-              GNUNET_i2s (&n->peer));
+              "Destroying neighbour entry for peer `%4s'\n",
+              GNUNET_i2s (&n->peer));
 #endif
   if (n->pitr != NULL)
-    {
-      GNUNET_PEERINFO_iterate_cancel (n->pitr);
-      n->pitr = NULL;
-    }
+  {
+    GNUNET_PEERINFO_iterate_cancel (n->pitr);
+    n->pitr = NULL;
+  }
   if (n->skm != NULL)
-    {
-      GNUNET_free (n->skm);
-      n->skm = NULL;
-    }
+  {
+    GNUNET_free (n->skm);
+    n->skm = NULL;
+  }
   while (NULL != (m = n->messages))
-    {
-      n->messages = m->next;
-      GNUNET_free (m);
-    }
+  {
+    n->messages = m->next;
+    GNUNET_free (m);
+  }
   while (NULL != (m = n->encrypted_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
-                                   n->encrypted_tail,
-                                   m);
-      GNUNET_free (m);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (n->encrypted_head, n->encrypted_tail, m);
+    GNUNET_free (m);
+  }
   while (NULL != (car = n->active_client_request_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (n->active_client_request_head,
-                                   n->active_client_request_tail,
-                                   car);
-      GNUNET_assert (GNUNET_YES ==
-                     GNUNET_CONTAINER_multihashmap_remove (car->client->requests,
-                                                           &n->peer.hashPubKey,
-                                                           car));
-      GNUNET_free (car);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (n->active_client_request_head,
+                                 n->active_client_request_tail, car);
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (car->client->requests,
+                                                         &n->peer.hashPubKey,
+                                                         car));
+    GNUNET_free (car);
+  }
   if (NULL != n->th)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (n->th);
-      n->th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (n->th);
+    n->th = NULL;
+  }
   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
@@ -1855,13 +1805,12 @@ free_neighbour (struct Neighbour *n)
     GNUNET_SCHEDULER_cancel (n->quota_update_task);
   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (n->dead_clean_task);
-  if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)    
-      GNUNET_SCHEDULER_cancel (n->keep_alive_task);
+  if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
+    GNUNET_SCHEDULER_cancel (n->keep_alive_task);
   if (n->status == PEER_STATE_KEY_CONFIRMED)
-    GNUNET_STATISTICS_update (stats, 
-                              gettext_noop ("# established sessions"), 
-                              -1, 
-                              GNUNET_NO);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# established sessions"),
+                              -1, GNUNET_NO);
   GNUNET_array_grow (n->ats, n->ats_count, 0);
   GNUNET_free_non_null (n->public_key);
   GNUNET_free_non_null (n->pending_ping);
@@ -1893,27 +1842,27 @@ static void process_encrypted_neighbour_queue (struct Neighbour *n);
  */
 static int
 do_encrypt (struct Neighbour *n,
-            const struct GNUNET_CRYPTO_AesInitializationVector * iv,
+            const struct GNUNET_CRYPTO_AesInitializationVector *iv,
             const void *in, void *out, size_t size)
 {
   if (size != (uint16_t) size)
-    {
-      GNUNET_break (0);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
   GNUNET_assert (size ==
                  GNUNET_CRYPTO_aes_encrypt (in,
                                             (uint16_t) size,
-                                            &n->encrypt_key,
-                                            iv, out));
-  GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes encrypted"), size, GNUNET_NO);
+                                            &n->encrypt_key, iv, out));
+  GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes encrypted"), size,
+                            GNUNET_NO);
 #if DEBUG_CORE > 2
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypted %u bytes for `%4s' using key %u, IV %u\n",
-              (unsigned int) size,
+              (unsigned int) size,
               GNUNET_i2s (&n->peer),
-              (unsigned int) n->encrypt_key.crc32,
-              GNUNET_CRYPTO_crc32_n (iv, sizeof(iv)));
+              (unsigned int) n->encrypt_key.crc32,
+              GNUNET_CRYPTO_crc32_n (iv, sizeof (iv)));
 #endif
   return GNUNET_OK;
 }
@@ -1925,8 +1874,7 @@ do_encrypt (struct Neighbour *n,
  *
  * @param n neighbour to consider discarding
  */
-static void
-consider_free_neighbour (struct Neighbour *n);
+static void consider_free_neighbour (struct Neighbour *n);
 
 
 /**
@@ -1937,8 +1885,7 @@ consider_free_neighbour (struct Neighbour *n);
  * @param tc scheduler context (not used)
  */
 static void
-send_keep_alive (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+send_keep_alive (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Neighbour *n = cls;
   struct GNUNET_TIME_Relative retry;
@@ -1956,26 +1903,23 @@ send_keep_alive (void *cls,
   me->priority = PING_PRIORITY;
   me->size = sizeof (struct PingMessage);
   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
-                                     n->encrypted_tail,
-                                     n->encrypted_tail,
-                                     me);
+                                     n->encrypted_tail, n->encrypted_tail, me);
   pm = (struct PingMessage *) &me[1];
   pm->header.size = htons (sizeof (struct PingMessage));
   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
   pm->iv_seed = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-      UINT32_MAX);
+                                          UINT32_MAX);
   derive_iv (&iv, &n->encrypt_key, pm->iv_seed, &n->peer);
   pp.challenge = n->ping_challenge;
   pp.target = n->peer;
 #if DEBUG_HANDSHAKE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypting `%s' message with challenge %u for `%4s' using key %u, IV %u (salt %u).\n",
-              "PING", 
-              (unsigned int) n->ping_challenge,
-              GNUNET_i2s (&n->peer),
-              (unsigned int) n->encrypt_key.crc32,
-              GNUNET_CRYPTO_crc32_n (&iv, sizeof(iv)),
-              pm->iv_seed);
+              "PING",
+              (unsigned int) n->ping_challenge,
+              GNUNET_i2s (&n->peer),
+              (unsigned int) n->encrypt_key.crc32,
+              GNUNET_CRYPTO_crc32_n (&iv, sizeof (iv)), pm->iv_seed);
 #endif
   do_encrypt (n,
               &iv,
@@ -1987,11 +1931,9 @@ send_keep_alive (void *cls,
   /* reschedule PING job */
   left = GNUNET_TIME_absolute_get_remaining (get_neighbour_timeout (n));
   retry = GNUNET_TIME_relative_max (GNUNET_TIME_relative_divide (left, 2),
-                                    MIN_PING_FREQUENCY);
-  n->keep_alive_task 
-    = GNUNET_SCHEDULER_add_delayed (retry,
-                                    &send_keep_alive,
-                                    n);
+                                    MIN_PING_FREQUENCY);
+  n->keep_alive_task
+      = GNUNET_SCHEDULER_add_delayed (retry, &send_keep_alive, n);
 
 }
 
@@ -2003,8 +1945,7 @@ send_keep_alive (void *cls,
  * @param tc scheduler context (not used)
  */
 static void
-consider_free_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+consider_free_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Neighbour *n = cls;
 
@@ -2021,33 +1962,29 @@ consider_free_task (void *cls,
  */
 static void
 consider_free_neighbour (struct Neighbour *n)
-{ 
+{
   struct GNUNET_TIME_Relative left;
 
-  if ( (n->th != NULL) ||
-       (n->pitr != NULL) ||
-       (GNUNET_YES == n->is_connected) )
-    return; /* no chance */
-    
+  if ((n->th != NULL) || (n->pitr != NULL) || (GNUNET_YES == n->is_connected))
+    return;                     /* no chance */
+
   left = GNUNET_TIME_absolute_get_remaining (get_neighbour_timeout (n));
   if (left.rel_value > 0)
-    {
-      if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (n->dead_clean_task);
-      n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (left,
-                                                         &consider_free_task,
-                                                         n);
-      return;
-    }
+  {
+    if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (n->dead_clean_task);
+    n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (left,
+                                                       &consider_free_task, n);
+    return;
+  }
   /* actually free the neighbour... */
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (neighbours,
-                                                       &n->peer.hashPubKey,
-                                                       n));
+                 GNUNET_CONTAINER_multihashmap_remove (neighbours,
+                                                       &n->peer.hashPubKey, n));
   GNUNET_STATISTICS_set (stats,
-                         gettext_noop ("# neighbour entries allocated"), 
-                         GNUNET_CONTAINER_multihashmap_size (neighbours),
-                         GNUNET_NO);
+                         gettext_noop ("# neighbour entries allocated"),
+                         GNUNET_CONTAINER_multihashmap_size (neighbours),
+                         GNUNET_NO);
   free_neighbour (n);
 }
 
@@ -2062,9 +1999,7 @@ consider_free_neighbour (struct Neighbour *n)
  * @return number of bytes transmitted
  */
 static size_t
-notify_encrypted_transmit_ready (void *cls, 
-                                 size_t size, 
-                                 void *buf)
+notify_encrypted_transmit_ready (void *cls, size_t size, void *buf)
 {
   struct Neighbour *n = cls;
   struct MessageEntry *m;
@@ -2074,50 +2009,48 @@ notify_encrypted_transmit_ready (void *cls,
   n->th = NULL;
   m = n->encrypted_head;
   if (m == NULL)
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Encrypted message queue empty, no messages added to buffer for `%4s'\n",
-                  GNUNET_i2s (&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Encrypted message queue empty, no messages added to buffer for `%4s'\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      return 0;
-    }
-  GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
-                               n->encrypted_tail,
-                               m);
+    return 0;
+  }
+  GNUNET_CONTAINER_DLL_remove (n->encrypted_head, n->encrypted_tail, m);
   ret = 0;
   cbuf = buf;
   if (buf != NULL)
-    {
-      GNUNET_assert (size >= m->size);
-      memcpy (cbuf, &m[1], m->size);
-      ret = m->size;
-      GNUNET_BANDWIDTH_tracker_consume (&n->available_send_window,
-                                        m->size);
+  {
+    GNUNET_assert (size >= m->size);
+    memcpy (cbuf, &m[1], m->size);
+    ret = m->size;
+    GNUNET_BANDWIDTH_tracker_consume (&n->available_send_window, m->size);
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Copied message of type %u and size %u into transport buffer for `%4s'\n",
-                  (unsigned int) ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
-                  (unsigned int) ret, 
-                  GNUNET_i2s (&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Copied message of type %u and size %u into transport buffer for `%4s'\n",
+                (unsigned int)
+                ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
+                (unsigned int) ret, GNUNET_i2s (&n->peer));
 #endif
-      process_encrypted_neighbour_queue (n);
-    }
+    process_encrypted_neighbour_queue (n);
+  }
   else
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission of message of type %u and size %u failed\n",
-                  (unsigned int) ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
-                  (unsigned int) m->size);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission of message of type %u and size %u failed\n",
+                (unsigned int)
+                ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
+                (unsigned int) m->size);
 #endif
-    }
+  }
   GNUNET_free (m);
   consider_free_neighbour (n);
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# encrypted bytes given to transport"), 
-                            ret, 
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop
+                            ("# encrypted bytes given to transport"), ret,
+                            GNUNET_NO);
   return ret;
 }
 
@@ -2143,47 +2076,46 @@ static void
 process_encrypted_neighbour_queue (struct Neighbour *n)
 {
   struct MessageEntry *m;
- 
+
   if (n->th != NULL)
-    return;  /* request already pending */
+    return;                     /* request already pending */
   if (GNUNET_YES != n->is_connected)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   m = n->encrypted_head;
   if (m == NULL)
-    {
-      /* encrypted queue empty, try plaintext instead */
-      process_plaintext_neighbour_queue (n);
-      return;
-    }
+  {
+    /* encrypted queue empty, try plaintext instead */
+    process_plaintext_neighbour_queue (n);
+    return;
+  }
 #if DEBUG_CORE > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asking transport for transmission of %u bytes to `%4s' in next %llu ms\n",
               (unsigned int) m->size,
               GNUNET_i2s (&n->peer),
-              (unsigned long long) GNUNET_TIME_absolute_get_remaining (m->deadline).rel_value);
+              (unsigned long long)
+              GNUNET_TIME_absolute_get_remaining (m->deadline).rel_value);
 #endif
   n->th =
-    GNUNET_TRANSPORT_notify_transmit_ready (transport, &n->peer,
-                                            m->size,
-                                            m->priority,
-                                            GNUNET_TIME_absolute_get_remaining
-                                            (m->deadline),
-                                            &notify_encrypted_transmit_ready,
-                                            n);
+      GNUNET_TRANSPORT_notify_transmit_ready (transport, &n->peer,
+                                              m->size,
+                                              m->priority,
+                                              GNUNET_TIME_absolute_get_remaining
+                                              (m->deadline),
+                                              &notify_encrypted_transmit_ready,
+                                              n);
   if (n->th == NULL)
-    {
-      /* message request too large or duplicate request */
-      GNUNET_break (0);
-      /* discard encrypted message */
-      GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
-                                   n->encrypted_tail,
-                                   m);
-      GNUNET_free (m);
-      process_encrypted_neighbour_queue (n);
-    }
+  {
+    /* message request too large or duplicate request */
+    GNUNET_break (0);
+    /* discard encrypted message */
+    GNUNET_CONTAINER_DLL_remove (n->encrypted_head, n->encrypted_tail, m);
+    GNUNET_free (m);
+    process_encrypted_neighbour_queue (n);
+  }
 }
 
 
@@ -2201,41 +2133,36 @@ process_encrypted_neighbour_queue (struct Neighbour *n)
  */
 static int
 do_decrypt (struct Neighbour *n,
-            const struct GNUNET_CRYPTO_AesInitializationVector * iv,
+            const struct GNUNET_CRYPTO_AesInitializationVector *iv,
             const void *in, void *out, size_t size)
 {
   if (size != (uint16_t) size)
-    {
-      GNUNET_break (0);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
   if ((n->status != PEER_STATE_KEY_RECEIVED) &&
       (n->status != PEER_STATE_KEY_CONFIRMED))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   if (size !=
-      GNUNET_CRYPTO_aes_decrypt (in,
-                                 (uint16_t) size,
-                                 &n->decrypt_key,
-                                 iv,
-                                 out))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# bytes decrypted"), 
-                            size, 
-                            GNUNET_NO);
+      GNUNET_CRYPTO_aes_decrypt (in, (uint16_t) size, &n->decrypt_key, iv, out))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# bytes decrypted"),
+                            size, GNUNET_NO);
 #if DEBUG_CORE > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Decrypted %u bytes from `%4s' using key %u, IV %u\n",
-              (unsigned int) size, 
-              GNUNET_i2s (&n->peer),
-              (unsigned int) n->decrypt_key.crc32,
-              GNUNET_CRYPTO_crc32_n (iv, sizeof(*iv)));
+              (unsigned int) size,
+              GNUNET_i2s (&n->peer),
+              (unsigned int) n->decrypt_key.crc32,
+              GNUNET_CRYPTO_crc32_n (iv, sizeof (*iv)));
 #endif
   return GNUNET_OK;
 }
@@ -2270,7 +2197,7 @@ select_messages (struct Neighbour *n,
   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_Relative delta;
   uint64_t avail;
-  struct GNUNET_TIME_Relative slack;     /* how long could we wait before missing deadlines? */
+  struct GNUNET_TIME_Relative slack;    /* how long could we wait before missing deadlines? */
   size_t off;
   uint64_t tsize;
   unsigned int queue_size;
@@ -2281,171 +2208,172 @@ select_messages (struct Neighbour *n,
   /* last entry in linked list of messages processed */
   last = NULL;
   /* should we remove the entry with the lowest
-     priority from consideration for scheduling at the
-     end of the loop? */
+   * priority from consideration for scheduling at the
+   * end of the loop? */
   queue_size = 0;
   tsize = 0;
   pos = n->messages;
   while (pos != NULL)
-    {
-      queue_size++;
-      tsize += pos->size;
-      pos = pos->next;
-    }
+  {
+    queue_size++;
+    tsize += pos->size;
+    pos = pos->next;
+  }
   discard_low_prio = GNUNET_YES;
   while (GNUNET_YES == discard_low_prio)
+  {
+    min = NULL;
+    min_prio = UINT_MAX;
+    discard_low_prio = GNUNET_NO;
+    /* calculate number of bytes available for transmission at time "t" */
+    avail = GNUNET_BANDWIDTH_tracker_get_available (&n->available_send_window);
+    t = now;
+    /* how many bytes have we (hypothetically) scheduled so far */
+    off = 0;
+    /* maximum time we can wait before transmitting anything
+     * and still make all of our deadlines */
+    slack = GNUNET_TIME_UNIT_FOREVER_REL;
+    pos = n->messages;
+    /* note that we use "*2" here because we want to look
+     * a bit further into the future; much more makes no
+     * sense since new message might be scheduled in the
+     * meantime... */
+    while ((pos != NULL) && (off < size * 2))
     {
-      min = NULL;
-      min_prio = UINT_MAX;
-      discard_low_prio = GNUNET_NO;
-      /* calculate number of bytes available for transmission at time "t" */
-      avail = GNUNET_BANDWIDTH_tracker_get_available (&n->available_send_window);
-      t = now;
-      /* how many bytes have we (hypothetically) scheduled so far */
-      off = 0;
-      /* maximum time we can wait before transmitting anything
-         and still make all of our deadlines */
-      slack = GNUNET_TIME_UNIT_FOREVER_REL;
-      pos = n->messages;
-      /* note that we use "*2" here because we want to look
-         a bit further into the future; much more makes no
-         sense since new message might be scheduled in the
-         meantime... */
-      while ((pos != NULL) && (off < size * 2))
-        {         
-          if (pos->do_transmit == GNUNET_YES)
-            {
-              /* already removed from consideration */
-              pos = pos->next;
-              continue;
-            }
-          if (discard_low_prio == GNUNET_NO)
-            {
-              delta = GNUNET_TIME_absolute_get_difference (t, pos->deadline);
-              if (delta.rel_value > 0)
-                {
-                  // FIXME: HUH? Check!
-                  t = pos->deadline;
-                  avail += GNUNET_BANDWIDTH_value_get_available_until (n->bw_out,
-                                                                       delta);
-                }
-              if (avail < pos->size)
-                {
-                  // FIXME: HUH? Check!
-                  discard_low_prio = GNUNET_YES;        /* we could not schedule this one! */
-                }
-              else
-                {
-                  avail -= pos->size;
-                  /* update slack, considering both its absolute deadline
-                     and relative deadlines caused by other messages
-                     with their respective load */
-                  slack = GNUNET_TIME_relative_min (slack,
-                                                    GNUNET_BANDWIDTH_value_get_delay_for (n->bw_out,
-                                                                                          avail));
-                  if (pos->deadline.abs_value <= now.abs_value) 
-                    {
-                      /* now or never */
-                      slack = GNUNET_TIME_UNIT_ZERO;
-                    }
-                  else if (GNUNET_YES == pos->got_slack)
-                    {
-                      /* should be soon now! */
-                      slack = GNUNET_TIME_relative_min (slack,
-                                                        GNUNET_TIME_absolute_get_remaining (pos->slack_deadline));
-                    }
-                  else
-                    {
-                      slack =
-                        GNUNET_TIME_relative_min (slack, 
-                                                  GNUNET_TIME_absolute_get_difference (now, pos->deadline));
-                      pos->got_slack = GNUNET_YES;
-                      pos->slack_deadline = GNUNET_TIME_absolute_min (pos->deadline,
-                                                                      GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY));
-                    }
-                }
-            }
-          off += pos->size;
-          t = GNUNET_TIME_absolute_max (pos->deadline, t); // HUH? Check!
-          if (pos->priority <= min_prio)
-            {
-              /* update min for discard */
-              min_prio = pos->priority;
-              min = pos;
-            }
-          pos = pos->next;
+      if (pos->do_transmit == GNUNET_YES)
+      {
+        /* already removed from consideration */
+        pos = pos->next;
+        continue;
+      }
+      if (discard_low_prio == GNUNET_NO)
+      {
+        delta = GNUNET_TIME_absolute_get_difference (t, pos->deadline);
+        if (delta.rel_value > 0)
+        {
+          // FIXME: HUH? Check!
+          t = pos->deadline;
+          avail += GNUNET_BANDWIDTH_value_get_available_until (n->bw_out,
+                                                               delta);
         }
-      if (discard_low_prio)
+        if (avail < pos->size)
         {
-          GNUNET_assert (min != NULL);
-          /* remove lowest-priority entry from consideration */
-          min->do_transmit = GNUNET_YES;        /* means: discard (for now) */
+          // FIXME: HUH? Check!
+          discard_low_prio = GNUNET_YES;        /* we could not schedule this one! */
         }
-      last = pos;
+        else
+        {
+          avail -= pos->size;
+          /* update slack, considering both its absolute deadline
+           * and relative deadlines caused by other messages
+           * with their respective load */
+          slack = GNUNET_TIME_relative_min (slack,
+                                            GNUNET_BANDWIDTH_value_get_delay_for
+                                            (n->bw_out, avail));
+          if (pos->deadline.abs_value <= now.abs_value)
+          {
+            /* now or never */
+            slack = GNUNET_TIME_UNIT_ZERO;
+          }
+          else if (GNUNET_YES == pos->got_slack)
+          {
+            /* should be soon now! */
+            slack = GNUNET_TIME_relative_min (slack,
+                                              GNUNET_TIME_absolute_get_remaining
+                                              (pos->slack_deadline));
+          }
+          else
+          {
+            slack =
+                GNUNET_TIME_relative_min (slack,
+                                          GNUNET_TIME_absolute_get_difference
+                                          (now, pos->deadline));
+            pos->got_slack = GNUNET_YES;
+            pos->slack_deadline = GNUNET_TIME_absolute_min (pos->deadline,
+                                                            GNUNET_TIME_relative_to_absolute
+                                                            (GNUNET_CONSTANTS_MAX_CORK_DELAY));
+          }
+        }
+      }
+      off += pos->size;
+      t = GNUNET_TIME_absolute_max (pos->deadline, t);  // HUH? Check!
+      if (pos->priority <= min_prio)
+      {
+        /* update min for discard */
+        min_prio = pos->priority;
+        min = pos;
+      }
+      pos = pos->next;
     }
+    if (discard_low_prio)
+    {
+      GNUNET_assert (min != NULL);
+      /* remove lowest-priority entry from consideration */
+      min->do_transmit = GNUNET_YES;    /* means: discard (for now) */
+    }
+    last = pos;
+  }
   /* guard against sending "tiny" messages with large headers without
-     urgent deadlines */
-  if ( (slack.rel_value > GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value) && 
-       (size > 4 * off) &&
-       (queue_size <= MAX_PEER_QUEUE_SIZE - 2) )
+   * urgent deadlines */
+  if ((slack.rel_value > GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value) &&
+      (size > 4 * off) && (queue_size <= MAX_PEER_QUEUE_SIZE - 2))
+  {
+    /* less than 25% of message would be filled with deadlines still
+     * being met if we delay by one second or more; so just wait for
+     * more data; but do not wait longer than 1s (since we don't want
+     * to delay messages for a really long time either). */
+    *retry_time = GNUNET_CONSTANTS_MAX_CORK_DELAY;
+    /* reset do_transmit values for next time */
+    while (pos != last)
     {
-      /* less than 25% of message would be filled with deadlines still
-         being met if we delay by one second or more; so just wait for
-         more data; but do not wait longer than 1s (since we don't want
-         to delay messages for a really long time either). */
-      *retry_time = GNUNET_CONSTANTS_MAX_CORK_DELAY;
-      /* reset do_transmit values for next time */
-      while (pos != last)
-        {
-          pos->do_transmit = GNUNET_NO;   
-          pos = pos->next;
-        }
-      GNUNET_STATISTICS_update (stats, 
-                                gettext_noop ("# transmissions delayed due to corking"), 
-                                1, GNUNET_NO);
+      pos->do_transmit = GNUNET_NO;
+      pos = pos->next;
+    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# transmissions delayed due to corking"), 1,
+                              GNUNET_NO);
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Deferring transmission for %llums due to underfull message buffer size (%u/%u)\n",
-                  (unsigned long long) retry_time->rel_value,
-                  (unsigned int) off,
-                  (unsigned int) size);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Deferring transmission for %llums due to underfull message buffer size (%u/%u)\n",
+                (unsigned long long) retry_time->rel_value,
+                (unsigned int) off, (unsigned int) size);
 #endif
-      return 0;
-    }
+    return 0;
+  }
   /* select marked messages (up to size) for transmission */
   off = 0;
   pos = n->messages;
   while (pos != last)
+  {
+    if ((pos->size <= size) && (pos->do_transmit == GNUNET_NO))
     {
-      if ((pos->size <= size) && (pos->do_transmit == GNUNET_NO))
-        {
-          pos->do_transmit = GNUNET_YES;        /* mark for transmission */
-          off += pos->size;
-          size -= pos->size;
+      pos->do_transmit = GNUNET_YES;    /* mark for transmission */
+      off += pos->size;
+      size -= pos->size;
 #if DEBUG_CORE > 1
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Selecting message of size %u for transmission\n",
-                      (unsigned int) pos->size);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Selecting message of size %u for transmission\n",
+                  (unsigned int) pos->size);
 #endif
-        }
-      else
-        {
+    }
+    else
+    {
 #if DEBUG_CORE > 1
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Not selecting message of size %u for transmission at this time (maximum is %u)\n",
-                      (unsigned int) pos->size,
-                      size);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Not selecting message of size %u for transmission at this time (maximum is %u)\n",
+                  (unsigned int) pos->size, size);
 #endif
-          pos->do_transmit = GNUNET_NO;   /* mark for not transmitting! */
-        }
-      pos = pos->next;
+      pos->do_transmit = GNUNET_NO;     /* mark for not transmitting! */
     }
+    pos = pos->next;
+  }
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Selected %llu/%llu bytes of %u/%u plaintext messages for transmission to `%4s'.\n",
               (unsigned long long) off, (unsigned long long) tsize,
-              queue_size, (unsigned int) MAX_PEER_QUEUE_SIZE,
-              GNUNET_i2s (&n->peer));
+              queue_size, (unsigned int) MAX_PEER_QUEUE_SIZE,
+              GNUNET_i2s (&n->peer));
 #endif
   return off;
 }
@@ -2468,29 +2396,28 @@ batch_message (struct Neighbour *n,
                char *buf,
                size_t size,
                struct GNUNET_TIME_Absolute *deadline,
-               struct GNUNET_TIME_Relative *retry_time,
-               unsigned int *priority)
+               struct GNUNET_TIME_Relative *retry_time, unsigned int *priority)
 {
   char ntmb[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
-  struct NotifyTrafficMessage *ntm = (struct NotifyTrafficMessage*) ntmb;
+  struct NotifyTrafficMessage *ntm = (struct NotifyTrafficMessage *) ntmb;
   struct MessageEntry *pos;
   struct MessageEntry *prev;
   struct MessageEntry *next;
   size_t ret;
-  
+
   ret = 0;
   *priority = 0;
   *deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
   *retry_time = GNUNET_TIME_UNIT_FOREVER_REL;
   if (0 == select_messages (n, size, retry_time))
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No messages selected, will try again in %llu ms\n",
-                  retry_time->rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No messages selected, will try again in %llu ms\n",
+                retry_time->rel_value);
 #endif
-      return 0;
-    }
+    return 0;
+  }
   ntm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND);
   ntm->ats_count = htonl (0);
   ntm->ats.type = htonl (0);
@@ -2499,72 +2426,74 @@ batch_message (struct Neighbour *n,
   pos = n->messages;
   prev = NULL;
   while ((pos != NULL) && (size >= sizeof (struct GNUNET_MessageHeader)))
+  {
+    next = pos->next;
+    if (GNUNET_YES == pos->do_transmit)
     {
-      next = pos->next;
-      if (GNUNET_YES == pos->do_transmit)
-        {
-          GNUNET_assert (pos->size <= size);
-          /* do notifications */
-          /* FIXME: track if we have *any* client that wants
-             full notifications and only do this if that is
-             actually true */
-          if (pos->size < GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct NotifyTrafficMessage))
-            {
-              memcpy (&ntm[1], &pos[1], pos->size);
-              ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) + 
-                                        sizeof (struct GNUNET_MessageHeader));
-              send_to_all_clients (&ntm->header,
-                                   GNUNET_YES,
-                                   GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
-            }
-          else
-            {
-              /* message too large for 'full' notifications, we do at
-                 least the 'hdr' type */
-              memcpy (&ntm[1],
-                      &pos[1],
-                      sizeof (struct GNUNET_MessageHeader));
-            }
-          ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) + 
-                                    pos->size);
-          send_to_all_clients (&ntm->header,
-                               GNUNET_YES,
-                               GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);   
+      GNUNET_assert (pos->size <= size);
+      /* do notifications */
+      /* FIXME: track if we have *any* client that wants
+       * full notifications and only do this if that is
+       * actually true */
+      if (pos->size <
+          GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct NotifyTrafficMessage))
+      {
+        memcpy (&ntm[1], &pos[1], pos->size);
+        ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) +
+                                  sizeof (struct GNUNET_MessageHeader));
+        send_to_all_clients (&ntm->header,
+                             GNUNET_YES, GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
+      }
+      else
+      {
+        /* message too large for 'full' notifications, we do at
+         * least the 'hdr' type */
+        memcpy (&ntm[1], &pos[1], sizeof (struct GNUNET_MessageHeader));
+      }
+      ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) +
+                                pos->size);
+      send_to_all_clients (&ntm->header,
+                           GNUNET_YES, GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
 #if DEBUG_HANDSHAKE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Encrypting %u bytes with message of type %u and size %u\n",
-                      pos->size,
-                      (unsigned int) ntohs(((const struct GNUNET_MessageHeader*)&pos[1])->type),
-                      (unsigned int) ntohs(((const struct GNUNET_MessageHeader*)&pos[1])->size));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Encrypting %u bytes with message of type %u and size %u\n",
+                  pos->size,
+                  (unsigned int)
+                  ntohs (((const struct GNUNET_MessageHeader *) &pos[1])->type),
+                  (unsigned int)
+                  ntohs (((const struct GNUNET_MessageHeader *)
+                          &pos[1])->size));
 #endif
-          /* copy for encrypted transmission */
-          memcpy (&buf[ret], &pos[1], pos->size);
-          ret += pos->size;
-          size -= pos->size;
-          *priority += pos->priority;
+      /* copy for encrypted transmission */
+      memcpy (&buf[ret], &pos[1], pos->size);
+      ret += pos->size;
+      size -= pos->size;
+      *priority += pos->priority;
 #if DEBUG_CORE > 1
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Adding plaintext message of size %u with deadline %llu ms to batch\n",
-                      (unsigned int) pos->size,
-                      (unsigned long long) GNUNET_TIME_absolute_get_remaining (pos->deadline).rel_value);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Adding plaintext message of size %u with deadline %llu ms to batch\n",
+                  (unsigned int) pos->size,
+                  (unsigned long long)
+                  GNUNET_TIME_absolute_get_remaining (pos->deadline).rel_value);
 #endif
-          deadline->abs_value = GNUNET_MIN (deadline->abs_value, pos->deadline.abs_value);
-          GNUNET_free (pos);
-          if (prev == NULL)
-            n->messages = next;
-          else
-            prev->next = next;
-        }
+      deadline->abs_value =
+          GNUNET_MIN (deadline->abs_value, pos->deadline.abs_value);
+      GNUNET_free (pos);
+      if (prev == NULL)
+        n->messages = next;
       else
-        {
-          prev = pos;
-        }
-      pos = next;
+        prev->next = next;
+    }
+    else
+    {
+      prev = pos;
     }
+    pos = next;
+  }
 #if DEBUG_CORE > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Deadline for message batch is %llu ms\n",
-              GNUNET_TIME_absolute_get_remaining (*deadline).rel_value);
+              "Deadline for message batch is %llu ms\n",
+              GNUNET_TIME_absolute_get_remaining (*deadline).rel_value);
 #endif
   return ret;
 }
@@ -2590,32 +2519,32 @@ discard_expired_messages (struct Neighbour *n)
   now = GNUNET_TIME_absolute_get ();
   prev = NULL;
   pos = n->messages;
-  while (pos != NULL) 
+  while (pos != NULL)
+  {
+    next = pos->next;
+    delta = GNUNET_TIME_absolute_get_difference (pos->deadline, now);
+    if (delta.rel_value > PAST_EXPIRATION_DISCARD_TIME.rel_value)
     {
-      next = pos->next;
-      delta = GNUNET_TIME_absolute_get_difference (pos->deadline, now);
-      if (delta.rel_value > PAST_EXPIRATION_DISCARD_TIME.rel_value)
-        {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      "Message is %llu ms past due, discarding.\n",
-                      delta.rel_value);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Message is %llu ms past due, discarding.\n",
+                  delta.rel_value);
 #endif
-          if (prev == NULL)
-            n->messages = next;
-          else
-            prev->next = next;
-          GNUNET_STATISTICS_update (stats, 
-                                    gettext_noop ("# messages discarded (expired prior to transmission)"), 
-                                    1, 
-                                    GNUNET_NO);
-          disc = GNUNET_YES;
-          GNUNET_free (pos);
-        }
+      if (prev == NULL)
+        n->messages = next;
       else
-        prev = pos;
-      pos = next;
+        prev->next = next;
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# messages discarded (expired prior to transmission)"),
+                                1, GNUNET_NO);
+      disc = GNUNET_YES;
+      GNUNET_free (pos);
     }
+    else
+      prev = pos;
+    pos = next;
+  }
   if (GNUNET_YES == disc)
     schedule_peer_messages (n);
 }
@@ -2656,12 +2585,11 @@ set_key_retry_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Retrying key transmission to `%4s'\n",
-              GNUNET_i2s (&n->peer));
+              "Retrying key transmission to `%4s'\n", GNUNET_i2s (&n->peer));
 #endif
   n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
   n->set_key_retry_frequency =
-    GNUNET_TIME_relative_multiply (n->set_key_retry_frequency, 2);
+      GNUNET_TIME_relative_multiply (n->set_key_retry_frequency, 2);
   send_key (n);
 }
 
@@ -2676,7 +2604,7 @@ set_key_retry_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 process_plaintext_neighbour_queue (struct Neighbour *n)
 {
-  char pbuf[GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE + sizeof (struct EncryptedMessage)];        /* plaintext */
+  char pbuf[GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE + sizeof (struct EncryptedMessage)];    /* plaintext */
   size_t used;
   struct EncryptedMessage *em;  /* encrypted message */
   struct EncryptedMessage *ph;  /* plaintext header */
@@ -2688,66 +2616,66 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
   struct GNUNET_CRYPTO_AuthKey auth_key;
 
   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
-      n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
+    n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   switch (n->status)
-    {
-    case PEER_STATE_DOWN:
-      send_key (n);
+  {
+  case PEER_STATE_DOWN:
+    send_key (n);
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
-                  GNUNET_i2s(&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      return;
-    case PEER_STATE_KEY_SENT:
-      if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
-        n->retry_set_key_task
-          = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
-                                          &set_key_retry_task, n);    
+    return;
+  case PEER_STATE_KEY_SENT:
+    if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
+      n->retry_set_key_task
+          = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
+                                          &set_key_retry_task, n);
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
-                  GNUNET_i2s(&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      return;
-    case PEER_STATE_KEY_RECEIVED:
-      if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)        
-        n->retry_set_key_task
-          = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
-                                          &set_key_retry_task, n);        
+    return;
+  case PEER_STATE_KEY_RECEIVED:
+    if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
+      n->retry_set_key_task
+          = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
+                                          &set_key_retry_task, n);
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
-                  GNUNET_i2s(&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      return;
-    case PEER_STATE_KEY_CONFIRMED:
-      /* ready to continue */
-      break;
-    }
+    return;
+  case PEER_STATE_KEY_CONFIRMED:
+    /* ready to continue */
+    break;
+  }
   discard_expired_messages (n);
   if (n->messages == NULL)
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Plaintext message queue for `%4s' is empty.\n",
-                  GNUNET_i2s(&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Plaintext message queue for `%4s' is empty.\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      return;                   /* no pending messages */
-    }
+    return;                     /* no pending messages */
+  }
   if (n->encrypted_head != NULL)
-    {
+  {
 #if DEBUG_CORE > 2
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Encrypted message queue for `%4s' is still full, delaying plaintext processing.\n",
-                  GNUNET_i2s(&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Encrypted message queue for `%4s' is still full, delaying plaintext processing.\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      return;                   /* wait for messages already encrypted to be
-                                   processed first! */
-    }
+    return;                     /* wait for messages already encrypted to be
+                                 * processed first! */
+  }
   ph = (struct EncryptedMessage *) pbuf;
   deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
   priority = 0;
@@ -2757,25 +2685,26 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
                          GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE,
                          &deadline, &retry_time, &priority);
   if (used == sizeof (struct EncryptedMessage))
-    {
+  {
 #if DEBUG_CORE > 1
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No messages selected for transmission to `%4s' at this time, will try again later.\n",
-                  GNUNET_i2s(&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No messages selected for transmission to `%4s' at this time, will try again later.\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      /* no messages selected for sending, try again later... */
-      n->retry_plaintext_task =
+    /* no messages selected for sending, try again later... */
+    n->retry_plaintext_task =
         GNUNET_SCHEDULER_add_delayed (retry_time,
                                       &retry_plaintext_processing, n);
-      return;
-    }
-#if DEBUG_CORE_QUOTA 
+    return;
+  }
+#if DEBUG_CORE_QUOTA
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending %u b/s as new limit to peer `%4s'\n",
-              (unsigned int) ntohl (n->bw_in.value__),
-              GNUNET_i2s (&n->peer));
+              "Sending %u b/s as new limit to peer `%4s'\n",
+              (unsigned int) ntohl (n->bw_in.value__), GNUNET_i2s (&n->peer));
 #endif
-  ph->iv_seed = htonl (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX));
+  ph->iv_seed =
+      htonl (GNUNET_CRYPTO_random_u32
+             (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX));
   ph->sequence_number = htonl (++n->last_sequence_number_sent);
   ph->inbound_bw_limit = n->bw_in;
   ph->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
@@ -2791,39 +2720,35 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
   em->iv_seed = ph->iv_seed;
   derive_iv (&iv, &n->encrypt_key, ph->iv_seed, &n->peer);
   /* encrypt */
-#if DEBUG_HANDSHAKE 
+#if DEBUG_HANDSHAKE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypting %u bytes of plaintext messages for `%4s' for transmission in %llums.\n",
-              (unsigned int) used - ENCRYPTED_HEADER_SIZE,
-              GNUNET_i2s(&n->peer),
-              (unsigned long long) GNUNET_TIME_absolute_get_remaining (deadline).rel_value);
+              (unsigned int) used - ENCRYPTED_HEADER_SIZE,
+              GNUNET_i2s (&n->peer),
+              (unsigned long long)
+              GNUNET_TIME_absolute_get_remaining (deadline).rel_value);
 #endif
   GNUNET_assert (GNUNET_OK ==
                  do_encrypt (n,
                              &iv,
                              &ph->sequence_number,
-                             &em->sequence_number, used - ENCRYPTED_HEADER_SIZE));
-  derive_auth_key (&auth_key,
-                   &n->encrypt_key,
-                   ph->iv_seed,
+                             &em->sequence_number,
+                             used - ENCRYPTED_HEADER_SIZE));
+  derive_auth_key (&auth_key, &n->encrypt_key, ph->iv_seed,
                    n->encrypt_key_created);
-  GNUNET_CRYPTO_hmac (&auth_key,
-                      &em->sequence_number,
-                      used - ENCRYPTED_HEADER_SIZE,
-                      &em->hmac);
+  GNUNET_CRYPTO_hmac (&auth_key, &em->sequence_number,
+                      used - ENCRYPTED_HEADER_SIZE, &em->hmac);
 #if DEBUG_HANDSHAKE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Authenticated %u bytes of ciphertext %u: `%s'\n",
               used - ENCRYPTED_HEADER_SIZE,
               GNUNET_CRYPTO_crc32_n (&em->sequence_number,
-                  used - ENCRYPTED_HEADER_SIZE),
+                                     used - ENCRYPTED_HEADER_SIZE),
               GNUNET_h2s (&em->hmac));
 #endif
   /* append to transmission list */
   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
-                                     n->encrypted_tail,
-                                     n->encrypted_tail,
-                                     me);
+                                     n->encrypted_tail, n->encrypted_tail, me);
   process_encrypted_neighbour_queue (n);
   schedule_peer_messages (n);
 }
@@ -2838,7 +2763,7 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
  */
 static void
 neighbour_quota_update (void *cls,
-                        const struct GNUNET_SCHEDULER_TaskContext *tc);
+                        const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -2849,12 +2774,10 @@ neighbour_quota_update (void *cls,
 static void
 schedule_quota_update (struct Neighbour *n)
 {
-  GNUNET_assert (n->quota_update_task ==
-                 GNUNET_SCHEDULER_NO_TASK);
+  GNUNET_assert (n->quota_update_task == GNUNET_SCHEDULER_NO_TASK);
   n->quota_update_task
-    = GNUNET_SCHEDULER_add_delayed (QUOTA_UPDATE_FREQUENCY,
-                                    &neighbour_quota_update,
-                                    n);
+      = GNUNET_SCHEDULER_add_delayed (QUOTA_UPDATE_FREQUENCY,
+                                      &neighbour_quota_update, n);
 }
 
 
@@ -2872,8 +2795,7 @@ create_neighbour (const struct GNUNET_PeerIdentity *pid)
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Creating neighbour entry for peer `%4s'\n",
-              GNUNET_i2s (pid));
+              "Creating neighbour entry for peer `%4s'\n", GNUNET_i2s (pid));
 #endif
   n = GNUNET_malloc (sizeof (struct Neighbour));
   n->peer = *pid;
@@ -2888,13 +2810,14 @@ create_neighbour (const struct GNUNET_PeerIdentity *pid)
   n->bw_out_external_limit = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
   n->ping_challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                                 UINT32_MAX);
-  GNUNET_assert (GNUNET_OK == 
-                 GNUNET_CONTAINER_multihashmap_put (neighbours,
-                                                    &n->peer.hashPubKey,
-                                                    n,
-                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), 
-                         GNUNET_CONTAINER_multihashmap_size (neighbours), GNUNET_NO);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (neighbours,
+                                                    &n->peer.hashPubKey,
+                                                    n,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"),
+                         GNUNET_CONTAINER_multihashmap_size (neighbours),
+                         GNUNET_NO);
   neighbour_quota_update (n, NULL);
   consider_free_neighbour (n);
   return n;
@@ -2917,7 +2840,7 @@ handle_client_send (void *cls,
   struct Neighbour *n;
   struct MessageEntry *prev;
   struct MessageEntry *pos;
-  struct MessageEntry *e; 
+  struct MessageEntry *e;
   struct MessageEntry *min_prio_entry;
   struct MessageEntry *min_prio_prev;
   unsigned int min_prio;
@@ -2927,124 +2850,122 @@ handle_client_send (void *cls,
   msize = ntohs (message->size);
   if (msize <
       sizeof (struct SendMessage) + sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                  "msize is %u, should be at least %u (in %s:%d)\n",
-                  msize,
-                  sizeof (struct SendMessage) + sizeof (struct GNUNET_MessageHeader),
-                  __FILE__, __LINE__);
-      GNUNET_break (0);
-      if (client != NULL)
-        GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "msize is %u, should be at least %u (in %s:%d)\n",
+                msize,
+                sizeof (struct SendMessage) +
+                sizeof (struct GNUNET_MessageHeader), __FILE__, __LINE__);
+    GNUNET_break (0);
+    if (client != NULL)
+      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   sm = (const struct SendMessage *) message;
   msize -= sizeof (struct SendMessage);
-  if (0 == memcmp (&sm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
-    {
-      /* loopback */
-      GNUNET_SERVER_mst_receive (mst,
-                                 &self,
-                                 (const char*) &sm[1],
-                                 msize,
-                                 GNUNET_YES,
-                                 GNUNET_NO);
-      if (client != NULL)
-        GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+  if (0 ==
+      memcmp (&sm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    /* loopback */
+    GNUNET_SERVER_mst_receive (mst,
+                               &self,
+                               (const char *) &sm[1],
+                               msize, GNUNET_YES, GNUNET_NO);
+    if (client != NULL)
+      GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   n = find_neighbour (&sm->peer);
-  if ( (n == NULL) ||
-       (GNUNET_YES != n->is_connected) ||
-       (n->status != PEER_STATE_KEY_CONFIRMED) )
-    {
-      /* attempt to send message to peer that is not connected anymore 
-         (can happen due to asynchrony) */      
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# messages discarded (disconnected)"), 
-                                1, 
-                                GNUNET_NO);
-      if (client != NULL)
-        GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+  if ((n == NULL) ||
+      (GNUNET_YES != n->is_connected) ||
+      (n->status != PEER_STATE_KEY_CONFIRMED))
+  {
+    /* attempt to send message to peer that is not connected anymore 
+     * (can happen due to asynchrony) */
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# messages discarded (disconnected)"), 1,
+                              GNUNET_NO);
+    if (client != NULL)
+      GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core received `%s' request, queueing %u bytes of plaintext data for transmission to `%4s'.\n",
-              "SEND",
-              (unsigned int) msize, 
-              GNUNET_i2s (&sm->peer));
+              "SEND", (unsigned int) msize, GNUNET_i2s (&sm->peer));
 #endif
   discard_expired_messages (n);
   /* bound queue size */
   /* NOTE: this entire block to bound the queue size should be
-     obsolete with the new client-request code and the
-     'schedule_peer_messages' mechanism; we still have this code in
-     here for now as a sanity check for the new mechanmism;
-     ultimately, we should probably simply reject SEND messages that
-     are not 'approved' (or provide a new core API for very unreliable
-     delivery that always sends with priority 0).  Food for thought. */
+   * obsolete with the new client-request code and the
+   * 'schedule_peer_messages' mechanism; we still have this code in
+   * here for now as a sanity check for the new mechanmism;
+   * ultimately, we should probably simply reject SEND messages that
+   * are not 'approved' (or provide a new core API for very unreliable
+   * delivery that always sends with priority 0).  Food for thought. */
   min_prio = UINT32_MAX;
   min_prio_entry = NULL;
   min_prio_prev = NULL;
   queue_size = 0;
   prev = NULL;
   pos = n->messages;
-  while (pos != NULL) 
+  while (pos != NULL)
+  {
+    if (pos->priority <= min_prio)
     {
-      if (pos->priority <= min_prio)
-        {
-          min_prio_entry = pos;
-          min_prio_prev = prev;
-          min_prio = pos->priority;
-        }
-      queue_size++;
-      prev = pos;
-      pos = pos->next;
+      min_prio_entry = pos;
+      min_prio_prev = prev;
+      min_prio = pos->priority;
     }
+    queue_size++;
+    prev = pos;
+    pos = pos->next;
+  }
   if (queue_size >= MAX_PEER_QUEUE_SIZE)
+  {
+    /* queue full */
+    if (ntohl (sm->priority) <= min_prio)
     {
-      /* queue full */
-      if (ntohl(sm->priority) <= min_prio)
-        {
-          /* discard new entry; this should no longer happen! */
-          GNUNET_break (0);
-#if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Queue full (%u/%u), discarding new request (%u bytes of type %u)\n",
-                      queue_size,
-                      (unsigned int) MAX_PEER_QUEUE_SIZE,
-                      (unsigned int) msize,
-                      (unsigned int) ntohs (message->type));
-#endif
-          GNUNET_STATISTICS_update (stats, 
-                                    gettext_noop ("# discarded CORE_SEND requests"), 
-                                    1, GNUNET_NO);
-
-          if (client != NULL)
-            GNUNET_SERVER_receive_done (client, GNUNET_OK);
-          return;
-        }
-      GNUNET_assert (min_prio_entry != NULL);
-      /* discard "min_prio_entry" */
+      /* discard new entry; this should no longer happen! */
+      GNUNET_break (0);
 #if DEBUG_CORE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Queue full, discarding existing older request\n");
+                  "Queue full (%u/%u), discarding new request (%u bytes of type %u)\n",
+                  queue_size,
+                  (unsigned int) MAX_PEER_QUEUE_SIZE,
+                  (unsigned int) msize, (unsigned int) ntohs (message->type));
 #endif
-          GNUNET_STATISTICS_update (stats, gettext_noop ("# discarded lower priority CORE_SEND requests"), 1, GNUNET_NO);
-      if (min_prio_prev == NULL)
-        n->messages = min_prio_entry->next;
-      else
-        min_prio_prev->next = min_prio_entry->next;      
-      GNUNET_free (min_prio_entry);     
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop ("# discarded CORE_SEND requests"),
+                                1, GNUNET_NO);
+
+      if (client != NULL)
+        GNUNET_SERVER_receive_done (client, GNUNET_OK);
+      return;
     }
+    GNUNET_assert (min_prio_entry != NULL);
+    /* discard "min_prio_entry" */
+#if DEBUG_CORE
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Queue full, discarding existing older request\n");
+#endif
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# discarded lower priority CORE_SEND requests"),
+                              1, GNUNET_NO);
+    if (min_prio_prev == NULL)
+      n->messages = min_prio_entry->next;
+    else
+      min_prio_prev->next = min_prio_entry->next;
+    GNUNET_free (min_prio_entry);
+  }
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding transmission request for `%4s' of size %u to queue\n",
-              GNUNET_i2s (&sm->peer),
-              (unsigned int) msize);
-#endif  
+              "Adding transmission request for `%4s' of size %u to queue\n",
+              GNUNET_i2s (&sm->peer), (unsigned int) msize);
+#endif
   GNUNET_break (0 == ntohl (sm->reserved));
   e = GNUNET_malloc (sizeof (struct MessageEntry) + msize);
   e->deadline = GNUNET_TIME_absolute_ntoh (sm->deadline);
@@ -3058,10 +2979,10 @@ handle_client_send (void *cls,
   prev = NULL;
   pos = n->messages;
   while ((pos != NULL) && (pos->deadline.abs_value < e->deadline.abs_value))
-    {
-      prev = pos;
-      pos = pos->next;
-    }
+  {
+    prev = pos;
+    pos = pos->next;
+  }
   if (prev == NULL)
     n->messages = e;
   else
@@ -3084,46 +3005,41 @@ handle_client_send (void *cls,
  */
 static void
 handle_client_request_connect (void *cls,
-                               struct GNUNET_SERVER_Client *client,
-                               const struct GNUNET_MessageHeader *message)
+                               struct GNUNET_SERVER_Client *client,
+                               const struct GNUNET_MessageHeader *message)
 {
-  const struct ConnectMessage *cm = (const struct ConnectMessage*) message;
+  const struct ConnectMessage *cm = (const struct ConnectMessage *) message;
   struct Neighbour *n;
 
-  if (0 == memcmp (&cm->peer, 
-                   &my_identity, 
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      /* In this case a client has asked us to connect to ourselves, not really an error! */
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }  
+  if (0 == memcmp (&cm->peer,
+                   &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    /* In this case a client has asked us to connect to ourselves, not really an error! */
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   GNUNET_break (ntohl (cm->reserved) == 0);
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Core received `%s' request for `%4s', will try to establish connection\n",
-              "REQUEST_CONNECT",
-              GNUNET_i2s (&cm->peer));
+              "Core received `%s' request for `%4s', will try to establish connection\n",
+              "REQUEST_CONNECT", GNUNET_i2s (&cm->peer));
 #endif
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# connection requests received"), 
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# connection requests received"),
+                            1, GNUNET_NO);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
   n = find_neighbour (&cm->peer);
-  if ( (n == NULL) || 
-       (GNUNET_YES != n->is_connected) )
-    {
-      GNUNET_TRANSPORT_try_connect (transport,
-                                    &cm->peer);
-    }
+  if ((n == NULL) || (GNUNET_YES != n->is_connected))
+  {
+    GNUNET_TRANSPORT_try_connect (transport, &cm->peer);
+  }
   else
-    {
-      GNUNET_STATISTICS_update (stats, 
-                                gettext_noop ("# connection requests ignored (already connected)"), 
-                                1,
-                                GNUNET_NO);
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# connection requests ignored (already connected)"),
+                              1, GNUNET_NO);
+  }
 }
 
 
@@ -3153,81 +3069,78 @@ process_hello_retry_send_key (void *cls,
   }
 
   if (peer == NULL)
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Entered `%s' and `%s' is NULL!\n",
-                  "process_hello_retry_send_key",
-                  "peer");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Entered `%s' and `%s' is NULL!\n",
+                "process_hello_retry_send_key", "peer");
 #endif
-      n->pitr = NULL;
-      if (n->public_key != NULL)
-        {
-          if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
-            {
-              GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
-              n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
-            }      
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# SET_KEY messages deferred (need public key)"), 
-                                    -1, 
-                                    GNUNET_NO);
-          send_key (n);
-        }
-      else
-        {
+    n->pitr = NULL;
+    if (n->public_key != NULL)
+    {
+      if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
+      {
+        GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
+        n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+      }
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# SET_KEY messages deferred (need public key)"),
+                                -1, GNUNET_NO);
+      send_key (n);
+    }
+    else
+    {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Failed to obtain public key for peer `%4s', delaying processing of SET_KEY\n",
-                      GNUNET_i2s (&n->peer));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Failed to obtain public key for peer `%4s', delaying processing of SET_KEY\n",
+                  GNUNET_i2s (&n->peer));
 #endif
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# Delayed connecting due to lack of public key"),
-                                    1,
-                                    GNUNET_NO);      
-          if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
-            n->retry_set_key_task
-              = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
-                                              &set_key_retry_task, n);
-        }
-      return;
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop
+                                ("# Delayed connecting due to lack of public key"),
+                                1, GNUNET_NO);
+      if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
+        n->retry_set_key_task
+            = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
+                                            &set_key_retry_task, n);
     }
+    return;
+  }
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Entered `%s' for peer `%4s'\n",
-              "process_hello_retry_send_key",
-              GNUNET_i2s (peer));
+              "process_hello_retry_send_key", GNUNET_i2s (peer));
 #endif
   if (n->public_key != NULL)
-    {
-      /* already have public key, why are we here? */
-      GNUNET_break (0);
-      return;
-    }
+  {
+    /* already have public key, why are we here? */
+    GNUNET_break (0);
+    return;
+  }
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received new `%s' message for `%4s', initiating key exchange.\n",
-              "HELLO",
-              GNUNET_i2s (peer));
+              "HELLO", GNUNET_i2s (peer));
 #endif
   n->public_key =
-    GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+      GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
-    {
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# Error extracting public key from HELLO"),
-                                1,
-                                GNUNET_NO);      
-      GNUNET_free (n->public_key);
-      n->public_key = NULL;
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# Error extracting public key from HELLO"), 1,
+                              GNUNET_NO);
+    GNUNET_free (n->public_key);
+    n->public_key = NULL;
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "GNUNET_HELLO_get_key returned awfully\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "GNUNET_HELLO_get_key returned awfully\n");
 #endif
-      return;
-    }
+    return;
+  }
 }
 
 
@@ -3247,121 +3160,115 @@ send_key (struct Neighbour *n)
   struct GNUNET_CRYPTO_AesInitializationVector iv;
 
   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
-      n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
-    }        
+  {
+    GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
+    n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (n->pitr != NULL)
-    {
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Key exchange in progress with `%4s'.\n",
-                  GNUNET_i2s (&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Key exchange in progress with `%4s'.\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      return; /* already in progress */
-    }
+    return;                     /* already in progress */
+  }
   if (GNUNET_YES != n->is_connected)
-    {
-      GNUNET_STATISTICS_update (stats, 
-                                gettext_noop ("# Asking transport to connect (for SET_KEY)"), 
-                                1, 
-                                GNUNET_NO);
-      GNUNET_TRANSPORT_try_connect (transport,
-                                    &n->peer);
-      return; 
-    }
+  {
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# Asking transport to connect (for SET_KEY)"),
+                              1, GNUNET_NO);
+    GNUNET_TRANSPORT_try_connect (transport, &n->peer);
+    return;
+  }
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asked to perform key exchange with `%4s'.\n",
               GNUNET_i2s (&n->peer));
 #endif
   if (n->public_key == NULL)
-    {
-      /* lookup n's public key, then try again */
+  {
+    /* lookup n's public key, then try again */
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Lacking public key for `%4s', trying to obtain one (send_key).\n",
-                  GNUNET_i2s (&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Lacking public key for `%4s', trying to obtain one (send_key).\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      GNUNET_assert (n->pitr == NULL);
-      n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
-                                         &n->peer,
-                                         GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20),
-                                         &process_hello_retry_send_key, n);
-      return;
-    }
+    GNUNET_assert (n->pitr == NULL);
+    n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
+                                       &n->peer,
+                                       GNUNET_TIME_relative_multiply
+                                       (GNUNET_TIME_UNIT_SECONDS, 20),
+                                       &process_hello_retry_send_key, n);
+    return;
+  }
   pos = n->encrypted_head;
   while (pos != NULL)
+  {
+    if (GNUNET_YES == pos->is_setkey)
     {
-      if (GNUNET_YES == pos->is_setkey)
-        {
-          if (pos->sender_status == n->status)
-            {
+      if (pos->sender_status == n->status)
+      {
 #if DEBUG_CORE
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "`%s' message for `%4s' queued already\n",
-                          "SET_KEY",
-                          GNUNET_i2s (&n->peer));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "`%s' message for `%4s' queued already\n",
+                    "SET_KEY", GNUNET_i2s (&n->peer));
 #endif
-              goto trigger_processing;
-            }
-          GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
-                                       n->encrypted_tail,
-                                       pos);
-          GNUNET_free (pos);
+        goto trigger_processing;
+      }
+      GNUNET_CONTAINER_DLL_remove (n->encrypted_head, n->encrypted_tail, pos);
+      GNUNET_free (pos);
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Removing queued `%s' message for `%4s', will create a new one\n",
-                      "SET_KEY",
-                      GNUNET_i2s (&n->peer));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Removing queued `%s' message for `%4s', will create a new one\n",
+                  "SET_KEY", GNUNET_i2s (&n->peer));
 #endif
-          break;
-        }
-      pos = pos->next;
+      break;
     }
+    pos = pos->next;
+  }
 
   /* update status */
   switch (n->status)
-    {
-    case PEER_STATE_DOWN:
-      n->status = PEER_STATE_KEY_SENT;
-      break;
-    case PEER_STATE_KEY_SENT:
-      break;
-    case PEER_STATE_KEY_RECEIVED:
-      break;
-    case PEER_STATE_KEY_CONFIRMED:
-      break;
-    default:
-      GNUNET_break (0);
-      break;
-    }
-  
+  {
+  case PEER_STATE_DOWN:
+    n->status = PEER_STATE_KEY_SENT;
+    break;
+  case PEER_STATE_KEY_SENT:
+    break;
+  case PEER_STATE_KEY_RECEIVED:
+    break;
+  case PEER_STATE_KEY_CONFIRMED:
+    break;
+  default:
+    GNUNET_break (0);
+    break;
+  }
+
 
   /* first, set key message */
   me = GNUNET_malloc (sizeof (struct MessageEntry) +
                       sizeof (struct SetKeyMessage) +
-                      sizeof (struct PingMessage));
+                      sizeof (struct PingMessage));
   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_SET_KEY_DELAY);
   me->priority = SET_KEY_PRIORITY;
   me->size = sizeof (struct SetKeyMessage) + sizeof (struct PingMessage);
   me->is_setkey = GNUNET_YES;
-  me->got_slack = GNUNET_YES; /* do not defer this one! */
+  me->got_slack = GNUNET_YES;   /* do not defer this one! */
   me->sender_status = n->status;
   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
-                                     n->encrypted_tail,
-                                     n->encrypted_tail,
-                                     me);
+                                     n->encrypted_tail, n->encrypted_tail, me);
   sm = (struct SetKeyMessage *) &me[1];
   sm->header.size = htons (sizeof (struct SetKeyMessage));
   sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SET_KEY);
   sm->sender_status = htonl ((int32_t) ((n->status == PEER_STATE_DOWN) ?
                                         PEER_STATE_KEY_SENT : n->status));
   sm->purpose.size =
-    htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
-           sizeof (struct GNUNET_TIME_AbsoluteNBO) +
-           sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
-           sizeof (struct GNUNET_PeerIdentity));
+      htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
+             sizeof (struct GNUNET_TIME_AbsoluteNBO) +
+             sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
+             sizeof (struct GNUNET_PeerIdentity));
   sm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SET_KEY);
   sm->creation_time = GNUNET_TIME_absolute_hton (n->encrypt_key_created);
   sm->target = n->peer;
@@ -3369,15 +3276,15 @@ send_key (struct Neighbour *n)
                  GNUNET_CRYPTO_rsa_encrypt (&n->encrypt_key,
                                             sizeof (struct
                                                     GNUNET_CRYPTO_AesSessionKey),
-                                            n->public_key,
-                                            &sm->encrypted_key));
+                                            n->public_key, &sm->encrypted_key));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CRYPTO_rsa_sign (my_private_key, &sm->purpose,
-                                         &sm->signature));  
+                                         &sm->signature));
   pm = (struct PingMessage *) &sm[1];
   pm->header.size = htons (sizeof (struct PingMessage));
   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
-  pm->iv_seed = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
+  pm->iv_seed =
+      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
   derive_iv (&iv, &n->encrypt_key, pm->iv_seed, &n->peer);
   pp.challenge = n->ping_challenge;
   pp.target = n->peer;
@@ -3385,11 +3292,10 @@ send_key (struct Neighbour *n)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypting `%s' and `%s' messages with challenge %u for `%4s' using key %u, IV %u (salt %u).\n",
               "SET_KEY", "PING",
-              (unsigned int) n->ping_challenge,
-              GNUNET_i2s (&n->peer),
-              (unsigned int) n->encrypt_key.crc32,
-              GNUNET_CRYPTO_crc32_n (&iv, sizeof(iv)),
-              pm->iv_seed);
+              (unsigned int) n->ping_challenge,
+              GNUNET_i2s (&n->peer),
+              (unsigned int) n->encrypt_key.crc32,
+              GNUNET_CRYPTO_crc32_n (&iv, sizeof (iv)), pm->iv_seed);
 #endif
   do_encrypt (n,
               &iv,
@@ -3397,24 +3303,25 @@ send_key (struct Neighbour *n)
               &pm->target,
               sizeof (struct PingMessage) -
               ((void *) &pm->target - (void *) pm));
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# SET_KEY and PING messages created"), 
-                            1, 
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop
+                            ("# SET_KEY and PING messages created"), 1,
+                            GNUNET_NO);
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Have %llu ms left for `%s' transmission.\n",
-              (unsigned long long) GNUNET_TIME_absolute_get_remaining (me->deadline).rel_value,
-              "SET_KEY");
+              (unsigned long long)
+              GNUNET_TIME_absolute_get_remaining (me->deadline).rel_value,
+              "SET_KEY");
 #endif
- trigger_processing:
+trigger_processing:
   /* trigger queue processing */
   process_encrypted_neighbour_queue (n);
-  if ( (n->status != PEER_STATE_KEY_CONFIRMED) &&
-       (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task) )
+  if ((n->status != PEER_STATE_KEY_CONFIRMED) &&
+      (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task))
     n->retry_set_key_task
-      = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
-                                      &set_key_retry_task, n);    
+        = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
+                                        &set_key_retry_task, n);
 }
 
 
@@ -3429,9 +3336,9 @@ send_key (struct Neighbour *n)
  */
 static void
 handle_set_key (struct Neighbour *n,
-                const struct SetKeyMessage *m,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-                uint32_t ats_count);
+                const struct SetKeyMessage *m,
+                const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                uint32_t ats_count);
 
 
 
@@ -3462,40 +3369,38 @@ process_hello_retry_handle_set_key (void *cls,
   }
 
   if (peer == NULL)
+  {
+    n->skm = NULL;
+    n->pitr = NULL;
+    if (n->public_key != NULL)
     {
-      n->skm = NULL;
-      n->pitr = NULL;
-      if (n->public_key != NULL)
-        {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Received `%s' for `%4s', continuing processing of `%s' message.\n",
-                      "HELLO",
-                      GNUNET_i2s (&n->peer),
-                      "SET_KEY");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Received `%s' for `%4s', continuing processing of `%s' message.\n",
+                  "HELLO", GNUNET_i2s (&n->peer), "SET_KEY");
 #endif
-          handle_set_key (n, sm, NULL, 0);
-        }
-      else
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      _("Ignoring `%s' message due to lack of public key for peer `%4s' (failed to obtain one).\n"),
-                      "SET_KEY",
-                      GNUNET_i2s (&n->peer));
-        }
-      GNUNET_free (sm);
-      return;
+      handle_set_key (n, sm, NULL, 0);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _
+                  ("Ignoring `%s' message due to lack of public key for peer `%4s' (failed to obtain one).\n"),
+                  "SET_KEY", GNUNET_i2s (&n->peer));
     }
+    GNUNET_free (sm);
+    return;
+  }
   if (n->public_key != NULL)
     return;                     /* multiple HELLOs match!? */
   n->public_key =
-    GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+      GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
-    {
-      GNUNET_break_op (0);
-      GNUNET_free (n->public_key);
-      n->public_key = NULL;
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_free (n->public_key);
+    n->public_key = NULL;
+  }
 }
 
 
@@ -3509,8 +3414,8 @@ process_hello_retry_handle_set_key (void *cls,
  */
 static void
 update_neighbour_performance (struct Neighbour *n,
-                              const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-                              uint32_t ats_count)
+                              const struct GNUNET_TRANSPORT_ATS_Information
+                              *ats, uint32_t ats_count)
 {
   uint32_t i;
   unsigned int j;
@@ -3518,22 +3423,20 @@ update_neighbour_performance (struct Neighbour *n,
   if (ats_count == 0)
     return;
   for (i = 0; i < ats_count; i++)
+  {
+    for (j = 0; j < n->ats_count; j++)
     {
-      for (j=0;j < n->ats_count; j++)
-        {
-          if (n->ats[j].type == ats[i].type)
-            {
-              n->ats[j].value = ats[i].value;
-              break;
-            }
-        }
-      if (j == n->ats_count)
-        {
-          GNUNET_array_append (n->ats,
-                               n->ats_count,
-                               ats[i]);
-        }
+      if (n->ats[j].type == ats[i].type)
+      {
+        n->ats[j].value = ats[i].value;
+        break;
+      }
     }
+    if (j == n->ats_count)
+    {
+      GNUNET_array_append (n->ats, n->ats_count, ats[i]);
+    }
+  }
 }
 
 
@@ -3548,9 +3451,9 @@ update_neighbour_performance (struct Neighbour *n,
  */
 static void
 handle_ping (struct Neighbour *n,
-             const struct PingMessage *m,
-             const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-             uint32_t ats_count)
+             const struct PingMessage *m,
+             const struct GNUNET_TRANSPORT_ATS_Information *ats,
+             uint32_t ats_count)
 {
   struct PingMessage t;
   struct PongMessage tx;
@@ -3578,37 +3481,32 @@ handle_ping (struct Neighbour *n,
               "PING",
               GNUNET_i2s (&t.target),
               (unsigned int) t.challenge,
-              (unsigned int) n->decrypt_key.crc32,
-              GNUNET_CRYPTO_crc32_n (&iv, sizeof(iv)),
-              m->iv_seed);
+              (unsigned int) n->decrypt_key.crc32,
+              GNUNET_CRYPTO_crc32_n (&iv, sizeof (iv)), m->iv_seed);
 #endif
   GNUNET_STATISTICS_update (stats,
-                            gettext_noop ("# PING messages decrypted"), 
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# PING messages decrypted"),
+                            1, GNUNET_NO);
   if (0 != memcmp (&t.target,
                    &my_identity, sizeof (struct GNUNET_PeerIdentity)))
-    {
-      char sender[9];
-      char peer[9];
-
-      GNUNET_snprintf(sender, sizeof (sender), "%8s", GNUNET_i2s (&n->peer));
-      GNUNET_snprintf(peer, sizeof (peer), "%8s", GNUNET_i2s (&t.target));
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Received PING from `%s' for different identity: I am `%s', PONG identity: `%s'\n"),
-                  sender,
-                  GNUNET_i2s (&my_identity), 
-                  peer);
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    char sender[9];
+    char peer[9];
+
+    GNUNET_snprintf (sender, sizeof (sender), "%8s", GNUNET_i2s (&n->peer));
+    GNUNET_snprintf (peer, sizeof (peer), "%8s", GNUNET_i2s (&t.target));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Received PING from `%s' for different identity: I am `%s', PONG identity: `%s'\n"),
+                sender, GNUNET_i2s (&my_identity), peer);
+    GNUNET_break_op (0);
+    return;
+  }
   update_neighbour_performance (n, ats, ats_count);
   me = GNUNET_malloc (sizeof (struct MessageEntry) +
                       sizeof (struct PongMessage));
   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
-                                     n->encrypted_tail,
-                                     n->encrypted_tail,
-                                     me);
+                                     n->encrypted_tail, n->encrypted_tail, me);
   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_PONG_DELAY);
   me->priority = PONG_PRIORITY;
   me->size = sizeof (struct PongMessage);
@@ -3618,7 +3516,8 @@ handle_ping (struct Neighbour *n,
   tp = (struct PongMessage *) &me[1];
   tp->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PONG);
   tp->header.size = htons (sizeof (struct PongMessage));
-  tp->iv_seed = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
+  tp->iv_seed =
+      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
   derive_pong_iv (&iv, &n->encrypt_key, tp->iv_seed, t.challenge, &n->peer);
   do_encrypt (n,
               &iv,
@@ -3626,18 +3525,16 @@ handle_ping (struct Neighbour *n,
               &tp->challenge,
               sizeof (struct PongMessage) -
               ((void *) &tp->challenge - (void *) tp));
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# PONG messages created"), 
-                            1, 
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# PONG messages created"),
+                            1, GNUNET_NO);
 #if DEBUG_HANDSHAKE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypting `%s' with challenge %u using key %u, IV %u (salt %u)\n",
-              "PONG",
+              "PONG",
               (unsigned int) t.challenge,
-              (unsigned int) n->encrypt_key.crc32,
-              GNUNET_CRYPTO_crc32_n (&iv, sizeof(iv)),
-              tp->iv_seed);
+              (unsigned int) n->encrypt_key.crc32,
+              GNUNET_CRYPTO_crc32_n (&iv, sizeof (iv)), tp->iv_seed);
 #endif
   /* trigger queue processing */
   process_encrypted_neighbour_queue (n);
@@ -3653,10 +3550,10 @@ handle_ping (struct Neighbour *n,
  * @param ats_count number of entries in ats (excluding 0-termination)
  */
 static void
-handle_pong (struct Neighbour *n, 
-             const struct PongMessage *m,
-             const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-             uint32_t ats_count)
+handle_pong (struct Neighbour *n,
+             const struct PongMessage *m,
+             const struct GNUNET_TRANSPORT_ATS_Information *ats,
+             uint32_t ats_count)
 {
   struct PongMessage t;
   struct ConnectNotifyMessage *cnm;
@@ -3673,7 +3570,7 @@ handle_pong (struct Neighbour *n,
   /* mark as garbage, just to be sure */
   memset (&t, 255, sizeof (t));
   derive_pong_iv (&iv, &n->decrypt_key, m->iv_seed, n->ping_challenge,
-      &my_identity);
+                  &my_identity);
   if (GNUNET_OK !=
       do_decrypt (n,
                   &iv,
@@ -3681,14 +3578,13 @@ handle_pong (struct Neighbour *n,
                   &t.challenge,
                   sizeof (struct PongMessage) -
                   ((void *) &m->challenge - (void *) m)))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# PONG messages decrypted"), 
-                            1, 
-                            GNUNET_NO);
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# PONG messages decrypted"),
+                            1, GNUNET_NO);
 #if DEBUG_HANDSHAKE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Decrypted `%s' from `%4s' with challenge %u using key %u, IV %u (salt %u)\n",
@@ -3696,115 +3592,107 @@ handle_pong (struct Neighbour *n,
               GNUNET_i2s (&t.target),
               (unsigned int) t.challenge,
               (unsigned int) n->decrypt_key.crc32,
-              GNUNET_CRYPTO_crc32_n (&iv, sizeof(iv)),
-              m->iv_seed);
+              GNUNET_CRYPTO_crc32_n (&iv, sizeof (iv)), m->iv_seed);
 #endif
   if ((0 != memcmp (&t.target,
                     &n->peer,
                     sizeof (struct GNUNET_PeerIdentity))) ||
       (n->ping_challenge != t.challenge))
-    {
-      /* PONG malformed */
+  {
+    /* PONG malformed */
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received malformed `%s' wanted sender `%4s' with challenge %u\n",
-                  "PONG", 
-                  GNUNET_i2s (&n->peer),
-                  (unsigned int) n->ping_challenge);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received malformed `%s' received from `%4s' with challenge %u\n",
-                  "PONG", GNUNET_i2s (&t.target), 
-                  (unsigned int) t.challenge);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received malformed `%s' wanted sender `%4s' with challenge %u\n",
+                "PONG",
+                GNUNET_i2s (&n->peer), (unsigned int) n->ping_challenge);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received malformed `%s' received from `%4s' with challenge %u\n",
+                "PONG", GNUNET_i2s (&t.target), (unsigned int) t.challenge);
 #endif
-      GNUNET_break_op (n->ping_challenge != t.challenge);
-      return;
-    }
+    GNUNET_break_op (n->ping_challenge != t.challenge);
+    return;
+  }
   switch (n->status)
+  {
+  case PEER_STATE_DOWN:
+    GNUNET_break (0);           /* should be impossible */
+    return;
+  case PEER_STATE_KEY_SENT:
+    GNUNET_break (0);           /* should be impossible, how did we decrypt? */
+    return;
+  case PEER_STATE_KEY_RECEIVED:
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# Session keys confirmed via PONG"), 1,
+                              GNUNET_NO);
+    n->status = PEER_STATE_KEY_CONFIRMED;
     {
-    case PEER_STATE_DOWN:
-      GNUNET_break (0);         /* should be impossible */
-      return;
-    case PEER_STATE_KEY_SENT:
-      GNUNET_break (0);         /* should be impossible, how did we decrypt? */
-      return;
-    case PEER_STATE_KEY_RECEIVED:
-      GNUNET_STATISTICS_update (stats, 
-                                gettext_noop ("# Session keys confirmed via PONG"), 
-                                1, 
-                                GNUNET_NO);
-      n->status = PEER_STATE_KEY_CONFIRMED;
-      {
-        struct GNUNET_MessageHeader *hdr;
+      struct GNUNET_MessageHeader *hdr;
 
-        hdr = compute_type_map_message ();
-        send_type_map_to_neighbour (hdr, &n->peer.hashPubKey, n);
-        GNUNET_free (hdr);
-      }
-      if (n->bw_out_external_limit.value__ != t.inbound_bw_limit.value__)
-        {
-          n->bw_out_external_limit = t.inbound_bw_limit;
-          n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
-                                                  n->bw_out_internal_limit);
-          GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
-                                                 n->bw_out);       
-          GNUNET_TRANSPORT_set_quota (transport,
-                                      &n->peer,
-                                      n->bw_in,
-                                      n->bw_out);
-        }
+      hdr = compute_type_map_message ();
+      send_type_map_to_neighbour (hdr, &n->peer.hashPubKey, n);
+      GNUNET_free (hdr);
+    }
+    if (n->bw_out_external_limit.value__ != t.inbound_bw_limit.value__)
+    {
+      n->bw_out_external_limit = t.inbound_bw_limit;
+      n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
+                                              n->bw_out_internal_limit);
+      GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
+                                             n->bw_out);
+      GNUNET_TRANSPORT_set_quota (transport, &n->peer, n->bw_in, n->bw_out);
+    }
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Confirmed key via `%s' message for peer `%4s'\n",
-                  "PONG", GNUNET_i2s (&n->peer));
-#endif      
-      if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
-          n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
-        }      
-      update_neighbour_performance (n, ats, ats_count);      
-      size = sizeof (struct ConnectNotifyMessage) +
-        (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
-      if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-        {
-          GNUNET_break (0);
-          /* recovery strategy: throw away performance data */
-          GNUNET_array_grow (n->ats,
-                             n->ats_count,
-                             0);
-          size = sizeof (struct PeerStatusNotifyMessage) +
-            n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
-        }
-      cnm = (struct ConnectNotifyMessage*) buf;
-      cnm->header.size = htons (size);
-      cnm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
-      cnm->ats_count = htonl (n->ats_count);
-      cnm->peer = n->peer;
-      mats = &cnm->ats;
-      memcpy (mats,
-              n->ats,
-              n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
-      mats[n->ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
-      mats[n->ats_count].value = htonl (0);      
-      send_to_all_clients (&cnm->header, 
-                           GNUNET_NO, 
-                           GNUNET_CORE_OPTION_SEND_CONNECT);
-      process_encrypted_neighbour_queue (n);
-      /* fall-through! */
-    case PEER_STATE_KEY_CONFIRMED:
-      n->last_activity = GNUNET_TIME_absolute_get ();
-      if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (n->keep_alive_task);
-      n->keep_alive_task 
-        = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
-                                        &send_keep_alive,
-                                        n);
-      handle_peer_status_change (n);
-      break;
-    default:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Confirmed key via `%s' message for peer `%4s'\n",
+                "PONG", GNUNET_i2s (&n->peer));
+#endif
+    if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
+      n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    update_neighbour_performance (n, ats, ats_count);
+    size = sizeof (struct ConnectNotifyMessage) +
+        (n->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+    if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+    {
       GNUNET_break (0);
-      break;
+      /* recovery strategy: throw away performance data */
+      GNUNET_array_grow (n->ats, n->ats_count, 0);
+      size = sizeof (struct PeerStatusNotifyMessage) +
+          n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
     }
+    cnm = (struct ConnectNotifyMessage *) buf;
+    cnm->header.size = htons (size);
+    cnm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
+    cnm->ats_count = htonl (n->ats_count);
+    cnm->peer = n->peer;
+    mats = &cnm->ats;
+    memcpy (mats,
+            n->ats,
+            n->ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
+    mats[n->ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
+    mats[n->ats_count].value = htonl (0);
+    send_to_all_clients (&cnm->header,
+                         GNUNET_NO, GNUNET_CORE_OPTION_SEND_CONNECT);
+    process_encrypted_neighbour_queue (n);
+    /* fall-through! */
+  case PEER_STATE_KEY_CONFIRMED:
+    n->last_activity = GNUNET_TIME_absolute_get ();
+    if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (n->keep_alive_task);
+    n->keep_alive_task
+        =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide
+                                      (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                       2), &send_keep_alive, n);
+    handle_peer_status_change (n);
+    break;
+  default:
+    GNUNET_break (0);
+    break;
+  }
 }
 
 
@@ -3818,10 +3706,10 @@ handle_pong (struct Neighbour *n,
  * @param ats_count number of entries in ats (excluding 0-termination)
  */
 static void
-handle_set_key (struct Neighbour *n, 
-                const struct SetKeyMessage *m,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-                uint32_t ats_count)
+handle_set_key (struct Neighbour *n,
+                const struct SetKeyMessage *m,
+                const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                uint32_t ats_count)
 {
   struct SetKeyMessage *m_cpy;
   struct GNUNET_TIME_Absolute t;
@@ -3836,45 +3724,44 @@ handle_set_key (struct Neighbour *n,
               "SET_KEY", GNUNET_i2s (&n->peer));
 #endif
   if (n->public_key == NULL)
+  {
+    if (n->pitr != NULL)
     {
-      if (n->pitr != NULL)
-        {
-#if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Ignoring `%s' message due to lack of public key for peer (still trying to obtain one).\n",
-                      "SET_KEY");
-#endif
-          return;
-        }
 #if DEBUG_CORE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Lacking public key for peer, trying to obtain one (handle_set_key).\n");
+                  "Ignoring `%s' message due to lack of public key for peer (still trying to obtain one).\n",
+                  "SET_KEY");
 #endif
-      m_cpy = GNUNET_malloc (sizeof (struct SetKeyMessage));
-      memcpy (m_cpy, m, sizeof (struct SetKeyMessage));
-      /* lookup n's public key, then try again */
-      GNUNET_assert (n->skm == NULL);
-      n->skm = m_cpy;
-      n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
-                                         &n->peer,
-                                         GNUNET_TIME_UNIT_MINUTES,
-                                         &process_hello_retry_handle_set_key, n);
-      GNUNET_STATISTICS_update (stats, 
-                                gettext_noop ("# SET_KEY messages deferred (need public key)"), 
-                                1, 
-                                GNUNET_NO);
       return;
     }
+#if DEBUG_CORE
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Lacking public key for peer, trying to obtain one (handle_set_key).\n");
+#endif
+    m_cpy = GNUNET_malloc (sizeof (struct SetKeyMessage));
+    memcpy (m_cpy, m, sizeof (struct SetKeyMessage));
+    /* lookup n's public key, then try again */
+    GNUNET_assert (n->skm == NULL);
+    n->skm = m_cpy;
+    n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
+                                       &n->peer,
+                                       GNUNET_TIME_UNIT_MINUTES,
+                                       &process_hello_retry_handle_set_key, n);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# SET_KEY messages deferred (need public key)"),
+                              1, GNUNET_NO);
+    return;
+  }
   if (0 != memcmp (&m->target,
-                   &my_identity,
-                   sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Received `%s' message that was for `%s', not for me.  Ignoring.\n"),
-                  "SET_KEY",
-                  GNUNET_i2s (&m->target));
-      return;
-    }
+                   &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _
+                ("Received `%s' message that was for `%s', not for me.  Ignoring.\n"),
+                "SET_KEY", GNUNET_i2s (&m->target));
+    return;
+  }
   if ((ntohl (m->purpose.size) !=
        sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
        sizeof (struct GNUNET_TIME_AbsoluteNBO) +
@@ -3883,107 +3770,103 @@ handle_set_key (struct Neighbour *n,
       (GNUNET_OK !=
        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_SET_KEY,
                                  &m->purpose, &m->signature, n->public_key)))
-    {
-      /* invalid signature */
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    /* invalid signature */
+    GNUNET_break_op (0);
+    return;
+  }
   t = GNUNET_TIME_absolute_ntoh (m->creation_time);
   if (((n->status == PEER_STATE_KEY_RECEIVED) ||
        (n->status == PEER_STATE_KEY_CONFIRMED)) &&
       (t.abs_value < n->decrypt_key_created.abs_value))
-    {
-      /* this could rarely happen due to massive re-ordering of
-         messages on the network level, but is most likely either
-         a bug or some adversary messing with us.  Report. */
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    /* this could rarely happen due to massive re-ordering of
+     * messages on the network level, but is most likely either
+     * a bug or some adversary messing with us.  Report. */
+    GNUNET_break_op (0);
+    return;
+  }
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Decrypting key material.\n");
-#endif  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting key material.\n");
+#endif
   if ((GNUNET_CRYPTO_rsa_decrypt (my_private_key,
                                   &m->encrypted_key,
                                   &k,
                                   sizeof (struct GNUNET_CRYPTO_AesSessionKey))
        != sizeof (struct GNUNET_CRYPTO_AesSessionKey)) ||
       (GNUNET_OK != GNUNET_CRYPTO_aes_check_session_key (&k)))
-    {
-      /* failed to decrypt !? */
-      GNUNET_break_op (0);
-      return;
-    }
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# SET_KEY messages decrypted"), 
-                            1, 
-                            GNUNET_NO);
+  {
+    /* failed to decrypt !? */
+    GNUNET_break_op (0);
+    return;
+  }
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# SET_KEY messages decrypted"),
+                            1, GNUNET_NO);
   n->decrypt_key = k;
   if (n->decrypt_key_created.abs_value != t.abs_value)
-    {
-      /* fresh key, reset sequence numbers */
-      n->last_sequence_number_received = 0;
-      n->last_packets_bitmap = 0;
-      n->decrypt_key_created = t;
-    }
+  {
+    /* fresh key, reset sequence numbers */
+    n->last_sequence_number_received = 0;
+    n->last_packets_bitmap = 0;
+    n->decrypt_key_created = t;
+  }
   update_neighbour_performance (n, ats, ats_count);
   sender_status = (enum PeerStateMachine) ntohl (m->sender_status);
   switch (n->status)
+  {
+  case PEER_STATE_DOWN:
+    n->status = PEER_STATE_KEY_RECEIVED;
+#if DEBUG_CORE
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Responding to `%s' with my own key.\n", "SET_KEY");
+#endif
+    send_key (n);
+    break;
+  case PEER_STATE_KEY_SENT:
+  case PEER_STATE_KEY_RECEIVED:
+    n->status = PEER_STATE_KEY_RECEIVED;
+    if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
+        (sender_status != PEER_STATE_KEY_CONFIRMED))
     {
-    case PEER_STATE_DOWN:
-      n->status = PEER_STATE_KEY_RECEIVED;
 #if DEBUG_CORE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Responding to `%s' with my own key.\n", "SET_KEY");
+                  "Responding to `%s' with my own key (other peer has status %u).\n",
+                  "SET_KEY", (unsigned int) sender_status);
 #endif
       send_key (n);
-      break;
-    case PEER_STATE_KEY_SENT:
-    case PEER_STATE_KEY_RECEIVED:
-      n->status = PEER_STATE_KEY_RECEIVED;
-      if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
-          (sender_status != PEER_STATE_KEY_CONFIRMED))
-        {
-#if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Responding to `%s' with my own key (other peer has status %u).\n",
-                      "SET_KEY",
-                      (unsigned int) sender_status);
-#endif
-          send_key (n);
-        }
-      break;
-    case PEER_STATE_KEY_CONFIRMED:
-      if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
-          (sender_status != PEER_STATE_KEY_CONFIRMED))
-        {         
+    }
+    break;
+  case PEER_STATE_KEY_CONFIRMED:
+    if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
+        (sender_status != PEER_STATE_KEY_CONFIRMED))
+    {
 #if DEBUG_CORE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Responding to `%s' with my own key (other peer has status %u), I was already fully up.\n",
-                      "SET_KEY", 
-                      (unsigned int) sender_status);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Responding to `%s' with my own key (other peer has status %u), I was already fully up.\n",
+                  "SET_KEY", (unsigned int) sender_status);
 #endif
-          send_key (n);
-        }
-      break;
-    default:
-      GNUNET_break (0);
-      break;
+      send_key (n);
     }
+    break;
+  default:
+    GNUNET_break (0);
+    break;
+  }
   if (n->pending_ping != NULL)
-    {
-      ping = n->pending_ping;
-      n->pending_ping = NULL;
-      handle_ping (n, ping, NULL, 0);
-      GNUNET_free (ping);
-    }
+  {
+    ping = n->pending_ping;
+    n->pending_ping = NULL;
+    handle_ping (n, ping, NULL, 0);
+    GNUNET_free (ping);
+  }
   if (n->pending_pong != NULL)
-    {
-      pong = n->pending_pong;
-      n->pending_pong = NULL;
-      handle_pong (n, pong, NULL, 0);
-      GNUNET_free (pong);
-    }
+  {
+    pong = n->pending_pong;
+    n->pending_pong = NULL;
+    handle_pong (n, pong, NULL, 0);
+    GNUNET_free (pong);
+  }
 }
 
 
@@ -3997,31 +3880,29 @@ handle_set_key (struct Neighbour *n,
  */
 static void
 send_p2p_message_to_client (struct Neighbour *sender,
-                            struct Client *client,
-                            const void *m, size_t msize)
+                            struct Client *client, const void *m, size_t msize)
 {
   size_t size = msize + sizeof (struct NotifyTrafficMessage) +
-    (sender->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+      (sender->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
   char buf[size];
   struct NotifyTrafficMessage *ntm;
   struct GNUNET_TRANSPORT_ATS_Information *ats;
 
   GNUNET_assert (GNUNET_YES == sender->is_connected);
   if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      /* recovery strategy: throw performance data away... */
-      GNUNET_array_grow (sender->ats,
-                         sender->ats_count,
-                         0);
-      size = msize + sizeof (struct NotifyTrafficMessage) +
-        (sender->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
-    }
+  {
+    GNUNET_break (0);
+    /* recovery strategy: throw performance data away... */
+    GNUNET_array_grow (sender->ats, sender->ats_count, 0);
+    size = msize + sizeof (struct NotifyTrafficMessage) +
+        (sender->ats_count) * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
+  }
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core service passes message from `%4s' of type %u to client.\n",
-              GNUNET_i2s(&sender->peer),
-              (unsigned int) ntohs (((const struct GNUNET_MessageHeader *) m)->type));
+              GNUNET_i2s (&sender->peer),
+              (unsigned int)
+              ntohs (((const struct GNUNET_MessageHeader *) m)->type));
 #endif
   ntm = (struct NotifyTrafficMessage *) buf;
   ntm->header.size = htons (size);
@@ -4030,13 +3911,11 @@ send_p2p_message_to_client (struct Neighbour *sender,
   ntm->peer = sender->peer;
   ats = &ntm->ats;
   memcpy (ats,
-          sender->ats,
-          sizeof (struct GNUNET_TRANSPORT_ATS_Information) * sender->ats_count);
+          sender->ats,
+          sizeof (struct GNUNET_TRANSPORT_ATS_Information) * sender->ats_count);
   ats[sender->ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
-  ats[sender->ats_count].value = htonl (0);  
-  memcpy (&ats[sender->ats_count+1],
-          m, 
-          msize);
+  ats[sender->ats_count].value = htonl (0);
+  memcpy (&ats[sender->ats_count + 1], m, msize);
   send_to_client (client, &ntm->header, GNUNET_YES);
 }
 
@@ -4049,9 +3928,7 @@ send_p2p_message_to_client (struct Neighbour *sender,
  * @param m the message
  */
 static void
-deliver_message (void *cls,
-                 void *client,
-                 const struct GNUNET_MessageHeader *m)
+deliver_message (void *cls, void *client, const struct GNUNET_MessageHeader *m)
 {
   struct Neighbour *sender = client;
   size_t msize = ntohs (m->size);
@@ -4065,66 +3942,61 @@ deliver_message (void *cls,
   type = ntohs (m->type);
 #if DEBUG_CORE > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received encapsulated message of type %u and size %u from `%4s'\n",
-              (unsigned int) type,
-              ntohs (m->size),
-              GNUNET_i2s (&sender->peer));
+              "Received encapsulated message of type %u and size %u from `%4s'\n",
+              (unsigned int) type, ntohs (m->size), GNUNET_i2s (&sender->peer));
 #endif
   GNUNET_snprintf (buf,
-                   sizeof(buf),
-                   gettext_noop ("# bytes of messages of type %u received"),
-                   (unsigned int) type);
-  GNUNET_STATISTICS_update (stats,
-                            buf,
-                            msize,
-                            GNUNET_NO);
-  if ( (GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP == type) ||
-       (GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP == type) )
-    {
-      /* FIXME: update message type map for 'Neighbour' */
-      return;
-    }
+                   sizeof (buf),
+                   gettext_noop ("# bytes of messages of type %u received"),
+                   (unsigned int) type);
+  GNUNET_STATISTICS_update (stats, buf, msize, GNUNET_NO);
+  if ((GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP == type) ||
+      (GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP == type))
+  {
+    /* FIXME: update message type map for 'Neighbour' */
+    return;
+  }
   dropped = GNUNET_YES;
   cpos = clients;
   while (cpos != NULL)
+  {
+    deliver_full = GNUNET_NO;
+    if (0 != (cpos->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))
+      deliver_full = GNUNET_YES;
+    else
     {
-      deliver_full = GNUNET_NO;
-      if (0 != (cpos->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))
+      for (tpos = 0; tpos < cpos->tcnt; tpos++)
+      {
+        if (type != cpos->types[tpos])
+          continue;
         deliver_full = GNUNET_YES;
-      else
-        {
-          for (tpos = 0; tpos < cpos->tcnt; tpos++)
-            {
-              if (type != cpos->types[tpos])
-                continue;
-              deliver_full = GNUNET_YES;
-              break;
-            }
-        }
-      if (GNUNET_YES == deliver_full)
-        {
-          send_p2p_message_to_client (sender, cpos, m, msize);
-          dropped = GNUNET_NO;
-        }
-      else if (cpos->options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)
-        {
-          send_p2p_message_to_client (sender, cpos, m,
-                                      sizeof (struct GNUNET_MessageHeader));
-        }
-      cpos = cpos->next;
+        break;
+      }
     }
-  if (dropped == GNUNET_YES)
+    if (GNUNET_YES == deliver_full)
     {
+      send_p2p_message_to_client (sender, cpos, m, msize);
+      dropped = GNUNET_NO;
+    }
+    else if (cpos->options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)
+    {
+      send_p2p_message_to_client (sender, cpos, m,
+                                  sizeof (struct GNUNET_MessageHeader));
+    }
+    cpos = cpos->next;
+  }
+  if (dropped == GNUNET_YES)
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Message of type %u from `%4s' not delivered to any client.\n",
-                  (unsigned int) type,
-                  GNUNET_i2s (&sender->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Message of type %u from `%4s' not delivered to any client.\n",
+                (unsigned int) type, GNUNET_i2s (&sender->peer));
 #endif
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# messages not delivered to any client"), 
-                                1, GNUNET_NO);
-    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# messages not delivered to any client"), 1,
+                              GNUNET_NO);
+  }
 }
 
 
@@ -4140,8 +4012,8 @@ deliver_message (void *cls,
 static void
 handle_encrypted_message (struct Neighbour *n,
                           const struct EncryptedMessage *m,
-                          const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-                          uint32_t ats_count)
+                          const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                          uint32_t ats_count)
 {
   size_t size = ntohs (m->header.size);
   char buf[size];
@@ -4156,147 +4028,140 @@ handle_encrypted_message (struct Neighbour *n,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core service receives `%s' request from `%4s'.\n",
               "ENCRYPTED_MESSAGE", GNUNET_i2s (&n->peer));
-#endif  
+#endif
   /* validate hash */
   derive_auth_key (&auth_key,
-                   &n->decrypt_key,
-                   m->iv_seed,
-                   n->decrypt_key_created);
+                   &n->decrypt_key, m->iv_seed, n->decrypt_key_created);
   GNUNET_CRYPTO_hmac (&auth_key,
-                      &m->sequence_number,
-                      size - ENCRYPTED_HEADER_SIZE, &ph);
+                      &m->sequence_number, size - ENCRYPTED_HEADER_SIZE, &ph);
 #if DEBUG_HANDSHAKE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Re-Authenticated %u bytes of ciphertext (`%u'): `%s'\n",
-              (unsigned int) size - ENCRYPTED_HEADER_SIZE,
+              (unsigned int) size - ENCRYPTED_HEADER_SIZE,
               GNUNET_CRYPTO_crc32_n (&m->sequence_number,
-                  size - ENCRYPTED_HEADER_SIZE),
-              GNUNET_h2s (&ph));
+                                     size - ENCRYPTED_HEADER_SIZE),
+              GNUNET_h2s (&ph));
 #endif
 
-  if (0 != memcmp (&ph,
-                   &m->hmac,
-                   sizeof (GNUNET_HashCode)))
-    {
-      /* checksum failed */
-      GNUNET_break_op (0);
-      return;
-    }
+  if (0 != memcmp (&ph, &m->hmac, sizeof (GNUNET_HashCode)))
+  {
+    /* checksum failed */
+    GNUNET_break_op (0);
+    return;
+  }
   derive_iv (&iv, &n->decrypt_key, m->iv_seed, &my_identity);
   /* decrypt */
   if (GNUNET_OK !=
       do_decrypt (n,
                   &iv,
                   &m->sequence_number,
-                  &buf[ENCRYPTED_HEADER_SIZE],
-                  size - ENCRYPTED_HEADER_SIZE))
+                  &buf[ENCRYPTED_HEADER_SIZE], size - ENCRYPTED_HEADER_SIZE))
     return;
   pt = (struct EncryptedMessage *) buf;
 
   /* validate sequence number */
   snum = ntohl (pt->sequence_number);
   if (n->last_sequence_number_received == snum)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "Received duplicate message, ignoring.\n");
-      /* duplicate, ignore */
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes dropped (duplicates)"),
-                                size,
-                                GNUNET_NO);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Received duplicate message, ignoring.\n");
+    /* duplicate, ignore */
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# bytes dropped (duplicates)"),
+                              size, GNUNET_NO);
+    return;
+  }
   if ((n->last_sequence_number_received > snum) &&
       (n->last_sequence_number_received - snum > 32))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Received ancient out of sequence message, ignoring.\n");
+    /* ancient out of sequence, ignore */
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# bytes dropped (out of sequence)"), size,
+                              GNUNET_NO);
+    return;
+  }
+  if (n->last_sequence_number_received > snum)
+  {
+    unsigned int rotbit = 1 << (n->last_sequence_number_received - snum - 1);
+
+    if ((n->last_packets_bitmap & rotbit) != 0)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "Received ancient out of sequence message, ignoring.\n");
-      /* ancient out of sequence, ignore */
+                  "Received duplicate message, ignoring.\n");
       GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes dropped (out of sequence)"),
-                                size,
-                                GNUNET_NO);
+                                gettext_noop ("# bytes dropped (duplicates)"),
+                                size, GNUNET_NO);
+      /* duplicate, ignore */
       return;
     }
-  if (n->last_sequence_number_received > snum)
-    {
-      unsigned int rotbit =
-        1 << (n->last_sequence_number_received - snum - 1);
-      if ((n->last_packets_bitmap & rotbit) != 0)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      "Received duplicate message, ignoring.\n");
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# bytes dropped (duplicates)"),
-                                    size,
-                                    GNUNET_NO);
-          /* duplicate, ignore */
-          return;
-        }
-      n->last_packets_bitmap |= rotbit;
-    }
+    n->last_packets_bitmap |= rotbit;
+  }
   if (n->last_sequence_number_received < snum)
-    {
-      int shift = (snum - n->last_sequence_number_received);
-      if (shift >= 8 * sizeof(n->last_packets_bitmap))
-        n->last_packets_bitmap = 0;
-      else
-        n->last_packets_bitmap <<= shift;
-      n->last_sequence_number_received = snum;
-    }
+  {
+    int shift = (snum - n->last_sequence_number_received);
+
+    if (shift >= 8 * sizeof (n->last_packets_bitmap))
+      n->last_packets_bitmap = 0;
+    else
+      n->last_packets_bitmap <<= shift;
+    n->last_sequence_number_received = snum;
+  }
 
   /* check timestamp */
   t = GNUNET_TIME_absolute_ntoh (pt->timestamp);
-  if (GNUNET_TIME_absolute_get_duration (t).rel_value > MAX_MESSAGE_AGE.rel_value)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _
-                  ("Message received far too old (%llu ms). Content ignored.\n"),
-                  GNUNET_TIME_absolute_get_duration (t).rel_value);
-      GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# bytes dropped (ancient message)"),
-                                size,
-                                GNUNET_NO);
-      return;
-    }
+  if (GNUNET_TIME_absolute_get_duration (t).rel_value >
+      MAX_MESSAGE_AGE.rel_value)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Message received far too old (%llu ms). Content ignored.\n"),
+                GNUNET_TIME_absolute_get_duration (t).rel_value);
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop
+                              ("# bytes dropped (ancient message)"), size,
+                              GNUNET_NO);
+    return;
+  }
 
   /* process decrypted message(s) */
   if (n->bw_out_external_limit.value__ != pt->inbound_bw_limit.value__)
-    {
+  {
 #if DEBUG_CORE_SET_QUOTA
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received %u b/s as new inbound limit for peer `%4s'\n",
-                  (unsigned int) ntohl (pt->inbound_bw_limit.value__),
-                  GNUNET_i2s (&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received %u b/s as new inbound limit for peer `%4s'\n",
+                (unsigned int) ntohl (pt->inbound_bw_limit.value__),
+                GNUNET_i2s (&n->peer));
 #endif
-      n->bw_out_external_limit = pt->inbound_bw_limit;
-      n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
-                                              n->bw_out_internal_limit);
-      GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
-                                             n->bw_out);
-      GNUNET_TRANSPORT_set_quota (transport,
-                                  &n->peer,
-                                  n->bw_in,
-                                  n->bw_out);
-    }
+    n->bw_out_external_limit = pt->inbound_bw_limit;
+    n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
+                                            n->bw_out_internal_limit);
+    GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
+                                           n->bw_out);
+    GNUNET_TRANSPORT_set_quota (transport, &n->peer, n->bw_in, n->bw_out);
+  }
   n->last_activity = GNUNET_TIME_absolute_get ();
   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (n->keep_alive_task);
-  n->keep_alive_task 
-    = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
-                                    &send_keep_alive,
-                                    n);
+  n->keep_alive_task
+      =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide
+                                    (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                     2), &send_keep_alive, n);
   GNUNET_STATISTICS_update (stats,
                             gettext_noop ("# bytes of payload decrypted"),
-                            size - sizeof (struct EncryptedMessage),
-                            GNUNET_NO);
+                            size - sizeof (struct EncryptedMessage), GNUNET_NO);
   handle_peer_status_change (n);
   update_neighbour_performance (n, ats, ats_count);
-  if (GNUNET_OK != GNUNET_SERVER_mst_receive (mst, 
-                                              n,
-                                              &buf[sizeof (struct EncryptedMessage)], 
-                                              size - sizeof (struct EncryptedMessage),
-                                              GNUNET_YES, GNUNET_NO))
+  if (GNUNET_OK != GNUNET_SERVER_mst_receive (mst,
+                                              n,
+                                              &buf[sizeof
+                                                   (struct EncryptedMessage)],
+                                              size -
+                                              sizeof (struct EncryptedMessage),
+                                              GNUNET_YES, GNUNET_NO))
     GNUNET_break_op (0);
 }
 
@@ -4314,8 +4179,8 @@ static void
 handle_transport_receive (void *cls,
                           const struct GNUNET_PeerIdentity *peer,
                           const struct GNUNET_MessageHeader *message,
-                          const struct GNUNET_TRANSPORT_ATS_Information *ats, 
-                          uint32_t ats_count)
+                          const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                          uint32_t ats_count)
 {
   struct Neighbour *n;
   struct GNUNET_TIME_Absolute now;
@@ -4327,134 +4192,130 @@ handle_transport_receive (void *cls,
 #if DEBUG_CORE > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received message of type %u from `%4s', demultiplexing.\n",
-              (unsigned int) ntohs (message->type), 
-              GNUNET_i2s (peer));
+              (unsigned int) ntohs (message->type), GNUNET_i2s (peer));
 #endif
   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   n = find_neighbour (peer);
-  if ( (n == NULL) || (GNUNET_NO == n->is_connected) )
-    {
-      /* received message from peer that is not connected!? */
-      GNUNET_break (0);
-      return;
-    }
+  if ((n == NULL) || (GNUNET_NO == n->is_connected))
+  {
+    /* received message from peer that is not connected!? */
+    GNUNET_break (0);
+    return;
+  }
   changed = GNUNET_NO;
   up = (n->status == PEER_STATE_KEY_CONFIRMED);
   type = ntohs (message->type);
   size = ntohs (message->size);
   switch (type)
+  {
+  case GNUNET_MESSAGE_TYPE_CORE_SET_KEY:
+    if (size != sizeof (struct SetKeyMessage))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# session keys received"),
+                              1, GNUNET_NO);
+    handle_set_key (n, (const struct SetKeyMessage *) message, ats, ats_count);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE:
+    if (size < sizeof (struct EncryptedMessage) +
+        sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    if ((n->status != PEER_STATE_KEY_RECEIVED) &&
+        (n->status != PEER_STATE_KEY_CONFIRMED))
     {
-    case GNUNET_MESSAGE_TYPE_CORE_SET_KEY:
-      if (size != sizeof (struct SetKeyMessage))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
       GNUNET_STATISTICS_update (stats,
-                                gettext_noop ("# session keys received"), 
-                                1, 
-                                GNUNET_NO);
-      handle_set_key (n,
-                      (const struct SetKeyMessage *) message,
-                      ats, ats_count);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE:
-      if (size < sizeof (struct EncryptedMessage) +
-          sizeof (struct GNUNET_MessageHeader))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      if ((n->status != PEER_STATE_KEY_RECEIVED) &&
-          (n->status != PEER_STATE_KEY_CONFIRMED))
-        {
-          GNUNET_STATISTICS_update (stats,
-                                    gettext_noop ("# failed to decrypt message (no session key)"), 
-                                    1, 
-                                    GNUNET_NO);
-          send_key (n);
-          return;
-        }
-      handle_encrypted_message (n, 
-                                (const struct EncryptedMessage *) message,
-                                ats, ats_count);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_PING:
-      if (size != sizeof (struct PingMessage))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      GNUNET_STATISTICS_update (stats, gettext_noop ("# PING messages received"), 1, GNUNET_NO);
-      if ((n->status != PEER_STATE_KEY_RECEIVED) &&
-          (n->status != PEER_STATE_KEY_CONFIRMED))
-        {
+                                gettext_noop
+                                ("# failed to decrypt message (no session key)"),
+                                1, GNUNET_NO);
+      send_key (n);
+      return;
+    }
+    handle_encrypted_message (n,
+                              (const struct EncryptedMessage *) message,
+                              ats, ats_count);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_PING:
+    if (size != sizeof (struct PingMessage))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    GNUNET_STATISTICS_update (stats, gettext_noop ("# PING messages received"),
+                              1, GNUNET_NO);
+    if ((n->status != PEER_STATE_KEY_RECEIVED) &&
+        (n->status != PEER_STATE_KEY_CONFIRMED))
+    {
 #if DEBUG_CORE > 1
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
-                      "PING", GNUNET_i2s (&n->peer));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
+                  "PING", GNUNET_i2s (&n->peer));
 #endif
-          GNUNET_free_non_null (n->pending_ping);
-          n->pending_ping = GNUNET_malloc (sizeof (struct PingMessage));
-          memcpy (n->pending_ping, message, sizeof (struct PingMessage));
-          return;
-        }
-      handle_ping (n, (const struct PingMessage *) message,
-                   ats, ats_count);
-      break;
-    case GNUNET_MESSAGE_TYPE_CORE_PONG:
-      if (size != sizeof (struct PongMessage))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      GNUNET_STATISTICS_update (stats, gettext_noop ("# PONG messages received"), 1, GNUNET_NO);
-      if ( (n->status != PEER_STATE_KEY_RECEIVED) &&
-           (n->status != PEER_STATE_KEY_CONFIRMED) )
-        {
+      GNUNET_free_non_null (n->pending_ping);
+      n->pending_ping = GNUNET_malloc (sizeof (struct PingMessage));
+      memcpy (n->pending_ping, message, sizeof (struct PingMessage));
+      return;
+    }
+    handle_ping (n, (const struct PingMessage *) message, ats, ats_count);
+    break;
+  case GNUNET_MESSAGE_TYPE_CORE_PONG:
+    if (size != sizeof (struct PongMessage))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    GNUNET_STATISTICS_update (stats, gettext_noop ("# PONG messages received"),
+                              1, GNUNET_NO);
+    if ((n->status != PEER_STATE_KEY_RECEIVED) &&
+        (n->status != PEER_STATE_KEY_CONFIRMED))
+    {
 #if DEBUG_CORE > 1
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
-                      "PONG", GNUNET_i2s (&n->peer));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
+                  "PONG", GNUNET_i2s (&n->peer));
 #endif
-          GNUNET_free_non_null (n->pending_pong);
-          n->pending_pong = GNUNET_malloc (sizeof (struct PongMessage));
-          memcpy (n->pending_pong, message, sizeof (struct PongMessage));
-          return;
-        }
-      handle_pong (n, (const struct PongMessage *) message,
-                   ats, ats_count);
-      break;
-    default:
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Unsupported message of type %u received.\n"),
-                  (unsigned int) type);
+      GNUNET_free_non_null (n->pending_pong);
+      n->pending_pong = GNUNET_malloc (sizeof (struct PongMessage));
+      memcpy (n->pending_pong, message, sizeof (struct PongMessage));
       return;
     }
+    handle_pong (n, (const struct PongMessage *) message, ats, ats_count);
+    break;
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Unsupported message of type %u received.\n"),
+                (unsigned int) type);
+    return;
+  }
   if (n->status == PEER_STATE_KEY_CONFIRMED)
+  {
+    now = GNUNET_TIME_absolute_get ();
+    n->last_activity = now;
+    changed = GNUNET_YES;
+    if (!up)
     {
-      now = GNUNET_TIME_absolute_get ();
-      n->last_activity = now;
-      changed = GNUNET_YES;
-      if (!up)
-        {
-          GNUNET_STATISTICS_update (stats, 
-                                    gettext_noop ("# established sessions"), 
-                                    1, 
-                                    GNUNET_NO);
-          n->time_established = now;
-        }
-      if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (n->keep_alive_task);
-      n->keep_alive_task 
-        = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
-                                        &send_keep_alive,
-                                        n);
+      GNUNET_STATISTICS_update (stats,
+                                gettext_noop ("# established sessions"),
+                                1, GNUNET_NO);
+      n->time_established = now;
     }
+    if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (n->keep_alive_task);
+    n->keep_alive_task
+        =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide
+                                      (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                       2), &send_keep_alive, n);
+  }
   if (changed)
     handle_peer_status_change (n);
 }
@@ -4469,7 +4330,7 @@ handle_transport_receive (void *cls,
  */
 static void
 neighbour_quota_update (void *cls,
-                        const struct GNUNET_SCHEDULER_TaskContext *tc)
+                        const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Neighbour *n = cls;
   struct GNUNET_BANDWIDTH_Value32NBO q_in;
@@ -4484,27 +4345,28 @@ neighbour_quota_update (void *cls,
 
 #if DEBUG_CORE > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Neighbour quota update calculation running for peer `%4s'\n",
-              GNUNET_i2s (&n->peer));  
+              "Neighbour quota update calculation running for peer `%4s'\n",
+              GNUNET_i2s (&n->peer));
 #endif
   n->quota_update_task = GNUNET_SCHEDULER_NO_TASK;
   /* calculate relative preference among all neighbours;
-     divides by a bit more to avoid division by zero AND to
-     account for possibility of new neighbours joining any time 
-     AND to convert to double... */
+   * divides by a bit more to avoid division by zero AND to
+   * account for possibility of new neighbours joining any time 
+   * AND to convert to double... */
   neighbour_count = GNUNET_CONTAINER_multihashmap_size (neighbours);
   if (neighbour_count == 0)
     return;
   if (preference_sum == 0)
-    {
-      pref_rel = 1.0 / (double) neighbour_count;
-    }
+  {
+    pref_rel = 1.0 / (double) neighbour_count;
+  }
   else
-    {
-      pref_rel = (double) n->current_preference / preference_sum;
-    }
-  need_per_peer = GNUNET_BANDWIDTH_value_get_available_until (MIN_BANDWIDTH_PER_PEER,
-                                                              GNUNET_TIME_UNIT_SECONDS);  
+  {
+    pref_rel = (double) n->current_preference / preference_sum;
+  }
+  need_per_peer =
+      GNUNET_BANDWIDTH_value_get_available_until (MIN_BANDWIDTH_PER_PEER,
+                                                  GNUNET_TIME_UNIT_SECONDS);
   need_per_second = need_per_peer * neighbour_count;
 
   /* calculate inbound bandwidth per peer */
@@ -4528,43 +4390,45 @@ neighbour_quota_update (void *cls,
     q_out = GNUNET_BANDWIDTH_value_init (need_per_peer + (uint32_t) share);
   n->bw_out_internal_limit = q_out;
 
-  q_out_min = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit, n->bw_out_internal_limit);
+  q_out_min =
+      GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
+                                  n->bw_out_internal_limit);
   GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window, n->bw_out);
 
   /* check if we want to disconnect for good due to inactivity */
-  if ( (GNUNET_TIME_absolute_get_duration (get_neighbour_timeout (n)).rel_value > 0) &&
-       (GNUNET_TIME_absolute_get_duration (n->time_established).rel_value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value) )
-    {
+  if ((GNUNET_TIME_absolute_get_duration (get_neighbour_timeout (n)).rel_value >
+       0) &&
+      (GNUNET_TIME_absolute_get_duration (n->time_established).rel_value >
+       GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value))
+  {
 #if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Forcing disconnect of `%4s' due to inactivity\n",
-                  GNUNET_i2s (&n->peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Forcing disconnect of `%4s' due to inactivity\n",
+                GNUNET_i2s (&n->peer));
 #endif
-      q_in = GNUNET_BANDWIDTH_value_init (0); /* force disconnect */
-    }
+    q_in = GNUNET_BANDWIDTH_value_init (0);     /* force disconnect */
+  }
 #if DEBUG_CORE_QUOTA
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Current quota for `%4s' is %u/%llu b/s in (old: %u b/s) / %u out (%u internal)\n",
-              GNUNET_i2s (&n->peer),
-              (unsigned int) ntohl (q_in.value__),
-              bandwidth_target_out_bps,
-              (unsigned int) ntohl (n->bw_in.value__),
-              (unsigned int) ntohl (n->bw_out.value__),
-              (unsigned int) ntohl (n->bw_out_internal_limit.value__));
-  #endif
-  if ((n->bw_in.value__ != q_in.value__) || (n->bw_out.value__ != q_out_min.value__))
-    {
-          if (n->bw_in.value__ != q_in.value__)
-                  n->bw_in = q_in;
-          if (n->bw_out.value__ != q_out_min.value__)
-                  n->bw_out = q_out_min;
-      if (GNUNET_YES == n->is_connected)
-        GNUNET_TRANSPORT_set_quota (transport,
-                                    &n->peer,
-                                    n->bw_in,
-                                    n->bw_out);
-      handle_peer_status_change (n);
-    }
+              "Current quota for `%4s' is %u/%llu b/s in (old: %u b/s) / %u out (%u internal)\n",
+              GNUNET_i2s (&n->peer),
+              (unsigned int) ntohl (q_in.value__),
+              bandwidth_target_out_bps,
+              (unsigned int) ntohl (n->bw_in.value__),
+              (unsigned int) ntohl (n->bw_out.value__),
+              (unsigned int) ntohl (n->bw_out_internal_limit.value__));
+#endif
+  if ((n->bw_in.value__ != q_in.value__) ||
+      (n->bw_out.value__ != q_out_min.value__))
+  {
+    if (n->bw_in.value__ != q_in.value__)
+      n->bw_in = q_in;
+    if (n->bw_out.value__ != q_out_min.value__)
+      n->bw_out = q_out_min;
+    if (GNUNET_YES == n->is_connected)
+      GNUNET_TRANSPORT_set_quota (transport, &n->peer, n->bw_in, n->bw_out);
+    handle_peer_status_change (n);
+  }
   schedule_quota_update (n);
 }
 
@@ -4581,52 +4445,45 @@ neighbour_quota_update (void *cls,
 static void
 handle_transport_notify_connect (void *cls,
                                  const struct GNUNET_PeerIdentity *peer,
-                                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                                 uint32_t ats_count)
+                                 const struct GNUNET_TRANSPORT_ATS_Information
+                                 *ats, uint32_t ats_count)
 {
   struct Neighbour *n;
 
   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   n = find_neighbour (peer);
   if (n != NULL)
+  {
+    if (GNUNET_YES == n->is_connected)
     {
-      if (GNUNET_YES == n->is_connected)
-        {
-          /* duplicate connect notification!? */
-          GNUNET_break (0);
-          return;
-        }
+      /* duplicate connect notification!? */
+      GNUNET_break (0);
+      return;
     }
+  }
   else
-    {
-      n = create_neighbour (peer);
-    }
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# peers connected (transport)"), 
-                            1, 
-                            GNUNET_NO);
-  n->is_connected = GNUNET_YES;      
+  {
+    n = create_neighbour (peer);
+  }
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# peers connected (transport)"),
+                            1, GNUNET_NO);
+  n->is_connected = GNUNET_YES;
   update_neighbour_performance (n, ats, ats_count);
   GNUNET_BANDWIDTH_tracker_init (&n->available_send_window,
-                                 n->bw_out,
-                                 MAX_WINDOW_TIME_S);
+                                 n->bw_out, MAX_WINDOW_TIME_S);
   GNUNET_BANDWIDTH_tracker_init (&n->available_recv_window,
-                                 n->bw_in,
-                                 MAX_WINDOW_TIME_S);  
+                                 n->bw_in, MAX_WINDOW_TIME_S);
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received connection from `%4s'.\n",
-              GNUNET_i2s (&n->peer));
+              "Received connection from `%4s'.\n", GNUNET_i2s (&n->peer));
 #endif
-  GNUNET_TRANSPORT_set_quota (transport,
-                              &n->peer,
-                              n->bw_in,
-                              n->bw_out);
-  send_key (n); 
+  GNUNET_TRANSPORT_set_quota (transport, &n->peer, n->bw_in, n->bw_out);
+  send_key (n);
 }
 
 
@@ -4648,67 +4505,65 @@ handle_transport_notify_disconnect (void *cls,
 
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected from us; received notification from transport.\n", 
-              GNUNET_i2s (peer));
+              "Peer `%4s' disconnected from us; received notification from transport.\n",
+              GNUNET_i2s (peer));
 #endif
   n = find_neighbour (peer);
   if (n == NULL)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   GNUNET_break (n->is_connected == GNUNET_YES);
   if (n->status == PEER_STATE_KEY_CONFIRMED)
-    {
-      cnm.header.size = htons (sizeof (struct DisconnectNotifyMessage));
-      cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
-      cnm.reserved = htonl (0);
-      cnm.peer = *peer;
-      send_to_all_clients (&cnm.header, GNUNET_NO, GNUNET_CORE_OPTION_SEND_DISCONNECT);
-      GNUNET_STATISTICS_update (stats, 
-                                gettext_noop ("# established sessions"), 
-                                -1, 
-                                GNUNET_NO);
-    }
+  {
+    cnm.header.size = htons (sizeof (struct DisconnectNotifyMessage));
+    cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
+    cnm.reserved = htonl (0);
+    cnm.peer = *peer;
+    send_to_all_clients (&cnm.header, GNUNET_NO,
+                         GNUNET_CORE_OPTION_SEND_DISCONNECT);
+    GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"),
+                              -1, GNUNET_NO);
+  }
 
   /* On transport disconnect transport doesn't cancel requests, so must do so here. */
   if (n->th != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (n->th);
-      n->th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (n->th);
+    n->th = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != n->keep_alive_task)
-    {
-      GNUNET_SCHEDULER_cancel (n->keep_alive_task);
-      n->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (n->keep_alive_task);
+    n->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   n->is_connected = GNUNET_NO;
   n->status = PEER_STATE_DOWN;
   while (NULL != (car = n->active_client_request_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (n->active_client_request_head,
-                                   n->active_client_request_tail,
-                                   car);
-      GNUNET_assert (GNUNET_YES ==
-                     GNUNET_CONTAINER_multihashmap_remove (car->client->requests,
-                                                           &n->peer.hashPubKey,
-                                                           car));
-      GNUNET_free (car);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (n->active_client_request_head,
+                                 n->active_client_request_tail, car);
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (car->client->requests,
+                                                         &n->peer.hashPubKey,
+                                                         car));
+    GNUNET_free (car);
+  }
 
-  GNUNET_STATISTICS_update (stats, 
-                            gettext_noop ("# peers connected (transport)"), 
-                            -1, 
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            gettext_noop ("# peers connected (transport)"),
+                            -1, GNUNET_NO);
   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (n->dead_clean_task);
-  left = GNUNET_TIME_relative_subtract (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
-                                        GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT);
-  n->last_activity = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (), 
-                                                    left);
-  n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
-                                                     &consider_free_task,
-                                                     n);
+  left =
+      GNUNET_TIME_relative_subtract (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                     GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT);
+  n->last_activity =
+      GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (), left);
+  n->dead_clean_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
+                                    &consider_free_task, n);
 }
 
 
@@ -4716,9 +4571,7 @@ handle_transport_notify_disconnect (void *cls,
  * Wrapper around 'free_neighbour'; helper for 'cleaning_task'.
  */
 static int
-free_neighbour_helper (void *cls,
-                       const GNUNET_HashCode *key,
-                       void *value)
+free_neighbour_helper (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct Neighbour *n = value;
 
@@ -4737,18 +4590,17 @@ cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct Client *c;
 
 #if DEBUG_CORE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Core service shutting down.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core service shutting down.\n");
 #endif
   GNUNET_assert (transport != NULL);
   GNUNET_TRANSPORT_disconnect (transport);
   transport = NULL;
   GNUNET_CONTAINER_multihashmap_iterate (neighbours,
-                                         &free_neighbour_helper,
-                                         NULL);
+                                         &free_neighbour_helper, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (neighbours);
   neighbours = NULL;
-  GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), 0, GNUNET_NO);
+  GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"),
+                         0, GNUNET_NO);
   GNUNET_SERVER_notification_context_destroy (notifier);
   notifier = NULL;
   while (NULL != (c = clients))
@@ -4784,7 +4636,8 @@ run (void *cls,
      sizeof (struct GNUNET_MessageHeader)},
     {&handle_client_have_peer, NULL,
      GNUNET_MESSAGE_TYPE_CORE_PEER_CONNECTED,
-     sizeof (struct GNUNET_MessageHeader) + sizeof(struct GNUNET_PeerIdentity)},
+     sizeof (struct GNUNET_MessageHeader) +
+     sizeof (struct GNUNET_PeerIdentity)},
     {&handle_client_request_info, NULL,
      GNUNET_MESSAGE_TYPE_CORE_REQUEST_INFO,
      sizeof (struct RequestInfoMessage)},
@@ -4800,49 +4653,48 @@ run (void *cls,
   };
   char *keyfile;
 
-  cfg = c;    
+  cfg = c;
   /* parse configuration */
-  if (
-       (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_number (c,
-                                               "CORE",
-                                               "TOTAL_QUOTA_IN",
-                                               &bandwidth_target_in_bps)) ||
-       (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_number (c,
-                                               "CORE",
-                                               "TOTAL_QUOTA_OUT",
-                                               &bandwidth_target_out_bps)) ||
-       (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_filename (c,
-                                                 "GNUNETD",
-                                                 "HOSTKEY", &keyfile)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Core service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_number (c,
+                                              "CORE",
+                                              "TOTAL_QUOTA_IN",
+                                              &bandwidth_target_in_bps)) ||
+      (GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_number (c,
+                                              "CORE",
+                                              "TOTAL_QUOTA_OUT",
+                                              &bandwidth_target_out_bps)) ||
+      (GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_filename (c,
+                                                "GNUNETD",
+                                                "HOSTKEY", &keyfile)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Core service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   peerinfo = GNUNET_PEERINFO_connect (cfg);
   if (NULL == peerinfo)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not access PEERINFO service.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      GNUNET_free (keyfile);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not access PEERINFO service.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_free (keyfile);
+    return;
+  }
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Core service could not access hostkey.  Exiting.\n"));
-      GNUNET_PEERINFO_disconnect (peerinfo);
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Core service could not access hostkey.  Exiting.\n"));
+    GNUNET_PEERINFO_disconnect (peerinfo);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   neighbours = GNUNET_CONTAINER_multihashmap_create (128);
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
   GNUNET_CRYPTO_hash (&my_public_key,
@@ -4853,12 +4705,12 @@ run (void *cls,
   self.status = PEER_STATE_KEY_CONFIRMED;
   self.is_connected = GNUNET_YES;
   /* setup notification */
-  notifier = GNUNET_SERVER_notification_context_create (server, 
-                                                        MAX_NOTIFY_QUEUE);
+  notifier = GNUNET_SERVER_notification_context_create (server,
+                                                        MAX_NOTIFY_QUEUE);
   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
   /* setup transport connection */
   transport = GNUNET_TRANSPORT_connect (cfg,
-                                        &my_identity,
+                                        &my_identity,
                                         NULL,
                                         &handle_transport_receive,
                                         &handle_transport_notify_connect,
@@ -4866,15 +4718,15 @@ run (void *cls,
   GNUNET_assert (NULL != transport);
   stats = GNUNET_STATISTICS_create ("core", cfg);
 
-  GNUNET_STATISTICS_set (stats, 
-                         gettext_noop ("# discarded CORE_SEND requests"), 
-                         0, GNUNET_NO);
-  GNUNET_STATISTICS_set (stats, 
-                         gettext_noop ("# discarded lower priority CORE_SEND requests"),
-                         0, GNUNET_NO);
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop ("# discarded CORE_SEND requests"),
+                         0, GNUNET_NO);
+  GNUNET_STATISTICS_set (stats,
+                         gettext_noop
+                         ("# discarded lower priority CORE_SEND requests"), 0,
+                         GNUNET_NO);
 
-  mst = GNUNET_SERVER_mst_create (&deliver_message,
-                                  NULL);
+  mst = GNUNET_SERVER_mst_create (&deliver_message, NULL);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &cleaning_task, NULL);
   /* process client requests */
@@ -4899,8 +4751,7 @@ main (int argc, char *const *argv)
           GNUNET_SERVICE_run (argc,
                               argv,
                               "core",
-                              GNUNET_SERVICE_OPTION_NONE,
-                              &run, NULL)) ? 0 : 1;
+                              GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
 }
 
 /* end of gnunet-service-core.c */
diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c
index d45560a5d..b5e93a8a2 100644
--- a/src/core/test_core_api.c
+++ b/src/core/test_core_api.c
@@ -44,7 +44,7 @@ struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;
-  struct GNUNET_PeerIdentity id;   
+  struct GNUNET_PeerIdentity id;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
   int connect_status;
@@ -71,14 +71,12 @@ static int ok;
 
 
 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_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received (my) `%s' from transport service\n",
-              "HELLO");
+              "Received (my) `%s' from transport service\n", "HELLO");
   GNUNET_assert (message != NULL);
   if ((p == &p1) && (p2.th != NULL))
     GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
@@ -105,31 +103,31 @@ static void
 terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 #if VERBOSE
-  fprintf(stderr, "ENDING ANGRILY %u\n", ok);
+  fprintf (stderr, "ENDING ANGRILY %u\n", ok);
 #endif
   GNUNET_break (0);
   if (NULL != p1.ch)
-    {
-      GNUNET_CORE_disconnect (p1.ch);
-      p1.ch = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (p1.ch);
+    p1.ch = NULL;
+  }
   if (NULL != p2.ch)
-    {
-      GNUNET_CORE_disconnect (p2.ch);
-      p2.ch = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (p2.ch);
+    p2.ch = NULL;
+  }
   if (p1.th != NULL)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &process_hello, &p1);
-      GNUNET_TRANSPORT_disconnect (p1.th);
-      p1.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p1.th, &process_hello, &p1);
+    GNUNET_TRANSPORT_disconnect (p1.th);
+    p1.th = NULL;
+  }
   if (p2.th != NULL)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &process_hello, &p2);
-      GNUNET_TRANSPORT_disconnect (p2.th);
-      p2.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p2.th, &process_hello, &p2);
+    GNUNET_TRANSPORT_disconnect (p2.th);
+    p2.th = NULL;
+  }
   ok = 42;
 }
 
@@ -154,54 +152,51 @@ transmit_ready (void *cls, size_t size, void *buf)
 static void
 connect_notify (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   GNUNET_assert (pc->connect_status == 0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection established to peer `%4s'\n",
-              GNUNET_i2s (peer));
+              "Encrypted connection established to peer `%4s'\n",
+              GNUNET_i2s (peer));
   if (GNUNET_SCHEDULER_NO_TASK != con_task)
-    {
-      GNUNET_SCHEDULER_cancel (con_task);
-      con_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (con_task);
+    con_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   pc->connect_status = 1;
   if (pc == &p1)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Asking core (1) for transmission to peer `%4s'\n",
+                GNUNET_i2s (&p2.id));
+    if (NULL == GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                   GNUNET_YES,
+                                                   0,
+                                                   GNUNET_TIME_relative_multiply
+                                                   (GNUNET_TIME_UNIT_SECONDS,
+                                                    45), &p2.id,
+                                                   sizeof (struct
+                                                           GNUNET_MessageHeader),
+                                                   &transmit_ready, &p1))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Asking core (1) for transmission to peer `%4s'\n",
-                  GNUNET_i2s (&p2.id));
-      if (NULL == GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                     GNUNET_YES,
-                                                     0,
-                                                     GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 45),
-                                                     &p2.id,
-                                                     sizeof (struct GNUNET_MessageHeader),
-                                                     &transmit_ready, &p1))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
-                      GNUNET_i2s (&p2.id));
-        }  
+                  "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
+                  GNUNET_i2s (&p2.id));
     }
+  }
 }
 
 
 static void
-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   pc->connect_status = 0;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -213,7 +208,7 @@ static int
 inbound_notify (void *cls,
                 const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core provides inbound data from `%4s'.\n", GNUNET_i2s (other));
@@ -225,7 +220,7 @@ static int
 outbound_notify (void *cls,
                  const struct GNUNET_PeerIdentity *other,
                  const struct GNUNET_MessageHeader *message,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core notifies about outbound data for `%4s'.\n",
@@ -239,7 +234,7 @@ static int
 process_mtype (void *cls,
                const struct GNUNET_PeerIdentity *peer,
                const struct GNUNET_MessageHeader *message,
-               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Receiving message from `%4s'.\n", GNUNET_i2s (peer));
@@ -258,23 +253,19 @@ static struct GNUNET_CORE_MessageHandler handlers[] = {
 
 
 static void
-connect_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    {
-      con_task = GNUNET_SCHEDULER_NO_TASK;
-      return;
-    }
+  {
+    con_task = GNUNET_SCHEDULER_NO_TASK;
+    return;
+  }
   con_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                           &connect_task,
-                                           NULL);
+                                           &connect_task, NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking core (1) to connect to peer `%4s'\n",
-              GNUNET_i2s (&p2.id));
-  GNUNET_CORE_peer_request_connect (p1.ch,
-                                    &p2.id,
-                                    NULL, NULL);
+              "Asking core (1) to connect to peer `%4s'\n",
+              GNUNET_i2s (&p2.id));
+  GNUNET_CORE_peer_request_connect (p1.ch, &p2.id, NULL, NULL);
 }
 
 static void
@@ -292,28 +283,27 @@ init_notify (void *cls,
   p->id = *my_identity;
   p->ch = server;
   if (cls == &p1)
-    {
-      GNUNET_assert (ok == 2);
-      OKPP;
-      /* connect p2 */
-      p2.ch = GNUNET_CORE_connect (p2.cfg, 1,
-                                   &p2,
-                                   &init_notify,                         
-                                   &connect_notify,
-                                   &disconnect_notify,
-                                   NULL,
-                                   &inbound_notify,
-                                   GNUNET_YES,
-                                   &outbound_notify, GNUNET_YES, handlers);
-    }
+  {
+    GNUNET_assert (ok == 2);
+    OKPP;
+    /* connect p2 */
+    p2.ch = GNUNET_CORE_connect (p2.cfg, 1,
+                                 &p2,
+                                 &init_notify,
+                                 &connect_notify,
+                                 &disconnect_notify,
+                                 NULL,
+                                 &inbound_notify,
+                                 GNUNET_YES,
+                                 &outbound_notify, GNUNET_YES, handlers);
+  }
   else
-    {
-      GNUNET_assert (ok == 3);
-      OKPP;
-      GNUNET_assert (cls == &p2);
-      con_task = GNUNET_SCHEDULER_add_now (&connect_task,
-                                           NULL);
-    }
+  {
+    GNUNET_assert (ok == 3);
+    OKPP;
+    GNUNET_assert (cls == &p2);
+    con_task = GNUNET_SCHEDULER_add_now (&connect_task, NULL);
+  }
 }
 
 
@@ -323,11 +313,11 @@ 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, NULL, NULL);
@@ -339,24 +329,20 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 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);
   OKPP;
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
-  err_task = 
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), 
-                                  &terminate_task_error, NULL);
-  p1.ch = GNUNET_CORE_connect (p1.cfg, 1,
-                               &p1,
-                               &init_notify,
-                               &connect_notify,
-                               &disconnect_notify,
-                               NULL,
-                               &inbound_notify,
-                               GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
+  err_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_SECONDS, 120),
+                                    &terminate_task_error, NULL);
+  p1.ch =
+      GNUNET_CORE_connect (p1.cfg, 1, &p1, &init_notify, &connect_notify,
+                           &disconnect_notify, NULL, &inbound_notify,
+                           GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
 }
 
 static void
@@ -365,10 +351,11 @@ stop_arm (struct PeerContext *p)
 #if START_ARM
   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
@@ -410,7 +397,7 @@ main (int argc, char *argv[])
 #endif
                     NULL);
   ret = check ();
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1"); 
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");
 
   return ret;
diff --git a/src/core/test_core_api_preferences.c b/src/core/test_core_api_preferences.c
index cc55f1644..200ae4176 100644
--- a/src/core/test_core_api_preferences.c
+++ b/src/core/test_core_api_preferences.c
@@ -41,7 +41,7 @@ struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;
-  struct GNUNET_PeerIdentity id;   
+  struct GNUNET_PeerIdentity id;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
   int connect_status;
@@ -75,13 +75,14 @@ static GNUNET_SCHEDULER_TaskIdentifier ask_task;
 static unsigned int total_reserve = 5;
 
 
-static void process_hello (void *cls, const struct GNUNET_MessageHeader *message);
+static void process_hello (void *cls,
+                           const struct GNUNET_MessageHeader *message);
 
 static void
 terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 #if VERBOSE
-  fprintf(stderr, "Regular shutdown\n");
+  fprintf (stderr, "Regular shutdown\n");
 #endif
   GNUNET_assert (ok == 6);
   GNUNET_assert (NULL == irc);
@@ -100,24 +101,24 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   err_task = GNUNET_SCHEDULER_NO_TASK;
 #if VERBOSE
-  fprintf(stderr, "ENDING ANGRILY %u\n", ok);
+  fprintf (stderr, "ENDING ANGRILY %u\n", ok);
 #endif
   GNUNET_break (0);
   if (NULL != irc)
-    {
-      GNUNET_CORE_peer_change_preference_cancel (irc);
-      irc = NULL;
-    }
+  {
+    GNUNET_CORE_peer_change_preference_cancel (irc);
+    irc = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != irc_task)
-    {
-      GNUNET_SCHEDULER_cancel (irc_task);
-      irc_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (irc_task);
+    irc_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != ask_task)
-    {
-      GNUNET_SCHEDULER_cancel (ask_task);
-      ask_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ask_task);
+    ask_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_TRANSPORT_get_hello_cancel (p1.th, &process_hello, &p1);
   GNUNET_TRANSPORT_get_hello_cancel (p2.th, &process_hello, &p2);
   GNUNET_CORE_disconnect (p1.ch);
@@ -142,160 +143,151 @@ transmit_ready (void *cls, size_t size, void *buf)
   m = (struct GNUNET_MessageHeader *) buf;
   m->type = htons (MTYPE);
   m->size = htons (sizeof (struct GNUNET_MessageHeader));
-  err_task = 
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), 
-                                  &terminate_task_error, NULL);
+  err_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_SECONDS, 120),
+                                    &terminate_task_error, NULL);
 
   return sizeof (struct GNUNET_MessageHeader);
 }
 
 static void
 preference_cb (void *cls,
-               const struct
-               GNUNET_PeerIdentity *peer,
-               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-               int32_t amount,
-               struct GNUNET_TIME_Relative res_delay,
-               uint64_t preference);
+               const struct
+               GNUNET_PeerIdentity *peer,
+               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+               int32_t amount,
+               struct GNUNET_TIME_Relative res_delay, uint64_t preference);
 
 static void
-do_reserve (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_reserve (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PeerContext *pc = cls;
 
   irc_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Aborted during attempt to request reservation\n");
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Aborted during attempt to request reservation\n");
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Requesting reservatin of 32k from core in 1s!\n");
+              "Requesting reservatin of 32k from core in 1s!\n");
   irc = GNUNET_CORE_peer_change_preference (p1.ch,
-                                            &p2.id,
-                                            GNUNET_TIME_UNIT_SECONDS,
-                                            GNUNET_BANDWIDTH_VALUE_MAX,
-                                            1000000 /* bandwidth for 1s */,
-                                            0,
-                                            &preference_cb,
-                                            pc);
+                                            &p2.id,
+                                            GNUNET_TIME_UNIT_SECONDS,
+                                            GNUNET_BANDWIDTH_VALUE_MAX,
+                                            1000000 /* bandwidth for 1s */ ,
+                                            0, &preference_cb, pc);
 }
 
 static void
 preference_cb (void *cls,
-               const struct
-               GNUNET_PeerIdentity *peer,
-               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-               int32_t amount,
-               struct GNUNET_TIME_Relative res_delay,
-               uint64_t preference)
+               const struct
+               GNUNET_PeerIdentity *peer,
+               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+               int32_t amount,
+               struct GNUNET_TIME_Relative res_delay, uint64_t preference)
 {
   struct PeerContext *pc = cls;
 
   irc = NULL;
   if (0 == amount)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Delaying reservation request by %llu ms!\n",
-                  (unsigned long long) res_delay.rel_value);
-      irc_task = GNUNET_SCHEDULER_add_delayed (res_delay,
-                                               &do_reserve, pc);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Delaying reservation request by %llu ms!\n",
+                (unsigned long long) res_delay.rel_value);
+    irc_task = GNUNET_SCHEDULER_add_delayed (res_delay, &do_reserve, pc);
+    return;
+  }
   total_reserve--;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Reservation done!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reservation done!\n");
   if (total_reserve > 0)
-    {
-      irc_task = GNUNET_SCHEDULER_add_now (&do_reserve, pc);
-      return;
-    }
+  {
+    irc_task = GNUNET_SCHEDULER_add_now (&do_reserve, pc);
+    return;
+  }
   GNUNET_SCHEDULER_cancel (err_task);
   err_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking core (1) for transmission to peer `%4s'\n",
-              GNUNET_i2s (&p2.id));
+              "Asking core (1) for transmission to peer `%4s'\n",
+              GNUNET_i2s (&p2.id));
   if (NULL == (th = GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                       GNUNET_YES,
-                                                       0,
-                                                       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 45),
-                                                       &p2.id,
-                                                       sizeof (struct GNUNET_MessageHeader),
-                                                       &transmit_ready, &p1)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
-                  GNUNET_i2s (&p2.id));
-    }    
+                                                       GNUNET_YES,
+                                                       0,
+                                                       GNUNET_TIME_relative_multiply
+                                                       (GNUNET_TIME_UNIT_SECONDS,
+                                                        45), &p2.id,
+                                                       sizeof (struct
+                                                               GNUNET_MessageHeader),
+                                                       &transmit_ready, &p1)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
+                GNUNET_i2s (&p2.id));
+  }
 }
 
 
 static void
 connect_notify (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   GNUNET_assert (pc->connect_status == 0);
   pc->connect_status = 1;
   if (pc == &p1)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Encrypted connection established to peer `%4s'\n",
+                GNUNET_i2s (peer));
+    if (GNUNET_SCHEDULER_NO_TASK != ask_task)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Encrypted connection established to peer `%4s'\n",
-                  GNUNET_i2s (peer));
-      if (GNUNET_SCHEDULER_NO_TASK != ask_task)
-        {
-          GNUNET_SCHEDULER_cancel (ask_task);
-          ask_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      GNUNET_SCHEDULER_cancel (err_task);
-      err_task = 
-        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), 
-                                      &terminate_task_error, NULL);
-      irc_task = GNUNET_SCHEDULER_add_now (&do_reserve, pc);
+      GNUNET_SCHEDULER_cancel (ask_task);
+      ask_task = GNUNET_SCHEDULER_NO_TASK;
     }
+    GNUNET_SCHEDULER_cancel (err_task);
+    err_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                      (GNUNET_TIME_UNIT_SECONDS, 120),
+                                      &terminate_task_error, NULL);
+    irc_task = GNUNET_SCHEDULER_add_now (&do_reserve, pc);
+  }
 }
 
 
 static void
-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   pc->connect_status = 0;
   if (GNUNET_SCHEDULER_NO_TASK != irc_task)
+  {
+    GNUNET_SCHEDULER_cancel (irc_task);
+    irc_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (0 == memcmp (peer, &p1.id, sizeof (struct GNUNET_PeerIdentity)))
+  {
+    if (irc != NULL)
     {
-      GNUNET_SCHEDULER_cancel (irc_task);
-      irc_task = GNUNET_SCHEDULER_NO_TASK;
+      GNUNET_CORE_peer_change_preference_cancel (irc);
+      irc = NULL;
     }
-  if (0 == memcmp (peer, &p1.id, sizeof (struct GNUNET_PeerIdentity)))
+    if (th != NULL)
     {
-      if (irc != NULL) 
-        {
-          GNUNET_CORE_peer_change_preference_cancel (irc);
-          irc = NULL;
-        }
-      if (th != NULL)
-        {
-          GNUNET_CORE_notify_transmit_ready_cancel (th);
-          th = NULL;
-        }
+      GNUNET_CORE_notify_transmit_ready_cancel (th);
+      th = NULL;
     }
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection to `%4s' cut\n", 
-              GNUNET_i2s (peer));
+              "Encrypted connection to `%4s' cut\n", GNUNET_i2s (peer));
 }
 
 
@@ -303,7 +295,7 @@ static int
 inbound_notify (void *cls,
                 const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core provides inbound data from `%4s'.\n", GNUNET_i2s (other));
@@ -315,7 +307,7 @@ static int
 outbound_notify (void *cls,
                  const struct GNUNET_PeerIdentity *other,
                  const struct GNUNET_MessageHeader *message,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core notifies about outbound data for `%4s'.\n",
@@ -329,7 +321,7 @@ static int
 process_mtype (void *cls,
                const struct GNUNET_PeerIdentity *peer,
                const struct GNUNET_MessageHeader *message,
-               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Receiving message from `%4s'.\n", GNUNET_i2s (peer));
@@ -349,19 +341,16 @@ static struct GNUNET_CORE_MessageHandler handlers[] = {
 
 
 
-static void 
-ask_connect_task (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+ask_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ask_task =
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                  &ask_connect_task, NULL);
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                    &ask_connect_task, NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking core (1) AGAIN to connect to peer `%4s'\n",
-              GNUNET_i2s (&p2.id));
-  GNUNET_CORE_peer_request_connect (p1.ch,
-                                    &p2.id,
-                                    NULL, NULL);
+              "Asking core (1) AGAIN to connect to peer `%4s'\n",
+              GNUNET_i2s (&p2.id));
+  GNUNET_CORE_peer_request_connect (p1.ch, &p2.id, NULL, NULL);
 }
 
 
@@ -380,52 +369,48 @@ init_notify (void *cls,
   p->id = *my_identity;
   p->ch = server;
   if (cls == &p1)
-    {
-      GNUNET_assert (ok == 2);
-      OKPP;
-      /* connect p2 */
-      GNUNET_CORE_connect (p2.cfg, 1,
-                           &p2,
-                           &init_notify,                         
-                           &connect_notify,
-                           &disconnect_notify,
-                           NULL,
-                           &inbound_notify,
-                           GNUNET_YES,
-                           &outbound_notify, GNUNET_YES, handlers);
-    }
+  {
+    GNUNET_assert (ok == 2);
+    OKPP;
+    /* connect p2 */
+    GNUNET_CORE_connect (p2.cfg, 1,
+                         &p2,
+                         &init_notify,
+                         &connect_notify,
+                         &disconnect_notify,
+                         NULL,
+                         &inbound_notify,
+                         GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
+  }
   else
-    {
-      GNUNET_assert (ok == 3);
-      OKPP;
-      GNUNET_assert (cls == &p2);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Asking core (1) to connect to peer `%4s'\n",
-                  GNUNET_i2s (&p2.id));
-      err_task = 
-        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60), 
-                                      &terminate_task_error, NULL);
-      if (GNUNET_SCHEDULER_NO_TASK != ask_task)
-        GNUNET_SCHEDULER_cancel (ask_task);
-      ask_task =
-        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                      &ask_connect_task, NULL);
-      GNUNET_CORE_peer_request_connect (p1.ch,
-                                        &p2.id,
-                                        NULL, NULL);
-    }
+  {
+    GNUNET_assert (ok == 3);
+    OKPP;
+    GNUNET_assert (cls == &p2);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Asking core (1) to connect to peer `%4s'\n",
+                GNUNET_i2s (&p2.id));
+    err_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                      (GNUNET_TIME_UNIT_SECONDS, 60),
+                                      &terminate_task_error, NULL);
+    if (GNUNET_SCHEDULER_NO_TASK != ask_task)
+      GNUNET_SCHEDULER_cancel (ask_task);
+    ask_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                      &ask_connect_task, NULL);
+    GNUNET_CORE_peer_request_connect (p1.ch, &p2.id, NULL, 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_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received (my) `%s' from transport service\n",
-              "HELLO");
+              "Received (my) `%s' from transport service\n", "HELLO");
   GNUNET_assert (message != NULL);
   p->hello = GNUNET_malloc (ntohs (message->size));
   memcpy (p->hello, message, ntohs (message->size));
@@ -448,11 +433,11 @@ 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, NULL, NULL);
@@ -464,8 +449,7 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 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);
   OKPP;
@@ -474,9 +458,9 @@ run (void *cls,
   GNUNET_CORE_connect (p1.cfg, 1,
                        &p1,
                        &init_notify,
-                       &connect_notify,
+                       &connect_notify,
                        &disconnect_notify,
-                       NULL,
+                       NULL,
                        &inbound_notify,
                        GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
 }
@@ -487,10 +471,11 @@ stop_arm (struct PeerContext *p)
 #if START_ARM
   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
@@ -513,7 +498,8 @@ check ()
   };
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-core-api-preferences", "nohelp", options, &run, &ok);
+                      argv, "test-core-api-preferences", "nohelp", options,
+                      &run, &ok);
   stop_arm (&p1);
   stop_arm (&p2);
   return ok;
@@ -532,7 +518,7 @@ main (int argc, char *argv[])
 #endif
                     NULL);
   ret = check ();
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1"); 
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");
 
   return ret;
diff --git a/src/core/test_core_api_reliability.c b/src/core/test_core_api_reliability.c
index b279acb91..1f82a0058 100644
--- a/src/core/test_core_api_reliability.c
+++ b/src/core/test_core_api_reliability.c
@@ -71,7 +71,7 @@ struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;
-  struct GNUNET_PeerIdentity id;   
+  struct GNUNET_PeerIdentity id;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
   int connect_status;
@@ -95,7 +95,7 @@ static int32_t tr_n;
 #define OKPP do { ok++; } while (0)
 #endif
 
-struct TestMessage 
+struct TestMessage
 {
   struct GNUNET_MessageHeader header;
   uint32_t num;
@@ -106,13 +106,15 @@ static unsigned int
 get_size (unsigned int iter)
 {
   unsigned int ret;
+
   if (iter < 60000)
     return iter + sizeof (struct TestMessage);
   ret = (iter * iter * iter);
   return sizeof (struct TestMessage) + (ret % 60000);
 }
 
-static void process_hello (void *cls, const struct GNUNET_MessageHeader *message);
+static void process_hello (void *cls,
+                           const struct GNUNET_MessageHeader *message);
 
 static void
 terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
@@ -131,9 +133,9 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   p2.th = NULL;
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
   fprintf (stderr,
-           "\nThroughput was %llu kb/s\n",
-           total_bytes * 1000 / 1024 / delta);
-  GAUGER ("CORE", "Core throughput/s", total_bytes * 1000 / 1024 / delta, "kb/s");
+           "\nThroughput was %llu kb/s\n", total_bytes * 1000 / 1024 / delta);
+  GAUGER ("CORE", "Core throughput/s", total_bytes * 1000 / 1024 / delta,
+          "kb/s");
   ok = 0;
 }
 
@@ -143,27 +145,27 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_break (0);
   if (p1.ch != NULL)
-    {
-      GNUNET_CORE_disconnect (p1.ch);
-      p1.ch = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (p1.ch);
+    p1.ch = NULL;
+  }
   if (p2.ch != NULL)
-    {
-      GNUNET_CORE_disconnect (p2.ch);
-      p2.ch = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (p2.ch);
+    p2.ch = NULL;
+  }
   if (p1.th != NULL)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &process_hello, &p1);
-      GNUNET_TRANSPORT_disconnect (p1.th);
-      p1.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p1.th, &process_hello, &p1);
+    GNUNET_TRANSPORT_disconnect (p1.th);
+    p1.th = NULL;
+  }
   if (p2.th != NULL)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &process_hello, &p2);
-      GNUNET_TRANSPORT_disconnect (p2.th);
-      p2.th = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p2.th, &process_hello, &p2);
+    GNUNET_TRANSPORT_disconnect (p2.th);
+    p2.th = NULL;
+  }
   ok = 42;
 }
 
@@ -176,20 +178,20 @@ transmit_ready (void *cls, size_t size, void *buf)
   unsigned int s;
   unsigned int ret;
 
-  GNUNET_assert (size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE); 
+  GNUNET_assert (size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE);
   if (buf == NULL)
-    {
-      if (p1.ch != NULL)
-        GNUNET_break (NULL != 
-                      GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                         GNUNET_NO,
-                                                         0,
-                                                         FAST_TIMEOUT,
-                                                         &p2.id,
-                                                         get_size(tr_n),
-                                                         &transmit_ready, &p1));
-      return 0;
-    }
+  {
+    if (p1.ch != NULL)
+      GNUNET_break (NULL !=
+                    GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                       GNUNET_NO,
+                                                       0,
+                                                       FAST_TIMEOUT,
+                                                       &p2.id,
+                                                       get_size (tr_n),
+                                                       &transmit_ready, &p1));
+    return 0;
+  }
   GNUNET_assert (tr_n < TOTAL_MSGS);
   ret = 0;
   s = get_size (tr_n);
@@ -197,35 +199,29 @@ transmit_ready (void *cls, size_t size, void *buf)
   GNUNET_assert (buf != NULL);
   cbuf = buf;
   do
-    {
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending message %u of size %u at offset %u\n",
-                  tr_n,
-                  s,
-                  ret);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending message %u of size %u at offset %u\n", tr_n, s, ret);
 #endif
-      hdr.header.size = htons (s);
-      hdr.header.type = htons (MTYPE);
-      hdr.num = htonl (tr_n);
-      memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
-      ret += sizeof (struct TestMessage);
-      memset (&cbuf[ret], tr_n, s - sizeof (struct TestMessage));
-      ret += s - sizeof (struct TestMessage);
-      tr_n++;
-      s = get_size (tr_n);
-      if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
-        break; /* sometimes pack buffer full, sometimes not */
-    }
+    hdr.header.size = htons (s);
+    hdr.header.type = htons (MTYPE);
+    hdr.num = htonl (tr_n);
+    memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+    ret += sizeof (struct TestMessage);
+    memset (&cbuf[ret], tr_n, s - sizeof (struct TestMessage));
+    ret += s - sizeof (struct TestMessage);
+    tr_n++;
+    s = get_size (tr_n);
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+      break;                    /* sometimes pack buffer full, sometimes not */
+  }
   while (size - ret >= s);
   GNUNET_SCHEDULER_cancel (err_task);
-  err_task = 
-    GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                  &terminate_task_error, 
-                                  NULL);
+  err_task =
+      GNUNET_SCHEDULER_add_delayed (TIMEOUT, &terminate_task_error, NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Returning total message block of size %u\n",
-              ret);
+              "Returning total message block of size %u\n", ret);
   total_bytes += ret;
   return ret;
 }
@@ -235,51 +231,44 @@ transmit_ready (void *cls, size_t size, void *buf)
 static void
 connect_notify (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   GNUNET_assert (pc->connect_status == 0);
   pc->connect_status = 1;
   if (pc == &p1)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Encrypted connection established to peer `%4s'\n",
-                  GNUNET_i2s (peer));
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Asking core (1) for transmission to peer `%4s'\n",
-                  GNUNET_i2s (&p2.id));
-      GNUNET_SCHEDULER_cancel (err_task);
-      err_task = 
-        GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                      &terminate_task_error, 
-                                      NULL);
-      start_time = GNUNET_TIME_absolute_get ();
-      GNUNET_break (NULL != 
-                    GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                       GNUNET_NO,
-                                                       0,
-                                                       TIMEOUT,
-                                                       &p2.id,
-                                                       get_size (0),
-                                                       &transmit_ready, &p1));
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Encrypted connection established to peer `%4s'\n",
+                GNUNET_i2s (peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Asking core (1) for transmission to peer `%4s'\n",
+                GNUNET_i2s (&p2.id));
+    GNUNET_SCHEDULER_cancel (err_task);
+    err_task =
+        GNUNET_SCHEDULER_add_delayed (TIMEOUT, &terminate_task_error, NULL);
+    start_time = GNUNET_TIME_absolute_get ();
+    GNUNET_break (NULL !=
+                  GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                     GNUNET_NO,
+                                                     0,
+                                                     TIMEOUT,
+                                                     &p2.id,
+                                                     get_size (0),
+                                                     &transmit_ready, &p1));
+  }
 }
 
 
 static void
-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   pc->connect_status = 0;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -291,7 +280,7 @@ static int
 inbound_notify (void *cls,
                 const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -305,7 +294,7 @@ static int
 outbound_notify (void *cls,
                  const struct GNUNET_PeerIdentity *other,
                  const struct GNUNET_MessageHeader *message,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -316,71 +305,65 @@ outbound_notify (void *cls,
 }
 
 
-static size_t
-transmit_ready (void *cls, size_t size, void *buf);
+static size_t transmit_ready (void *cls, size_t size, void *buf);
 
 static int
 process_mtype (void *cls,
                const struct GNUNET_PeerIdentity *peer,
                const struct GNUNET_MessageHeader *message,
-               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   static int n;
   unsigned int s;
   const struct TestMessage *hdr;
 
-  hdr = (const struct TestMessage*) message;
+  hdr = (const struct TestMessage *) message;
   s = get_size (n);
   if (MTYPE != ntohs (message->type))
     return GNUNET_SYSERR;
   if (ntohs (message->size) != s)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      GNUNET_SCHEDULER_cancel (err_task);
-      err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, s, ntohs (message->size), ntohl (hdr->num));
+    GNUNET_SCHEDULER_cancel (err_task);
+    err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
+    return GNUNET_SYSERR;
+  }
   if (ntohl (hdr->num) != n)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      GNUNET_SCHEDULER_cancel (err_task);
-      err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, s, ntohs (message->size), ntohl (hdr->num));
+    GNUNET_SCHEDULER_cancel (err_task);
+    err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
+    return GNUNET_SYSERR;
+  }
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got message %u of size %u\n",
-              ntohl (hdr->num),
-              ntohs (message->size));         
+              "Got message %u of size %u\n",
+              ntohl (hdr->num), ntohs (message->size));
 #endif
   n++;
-  if (0 == (n % (TOTAL_MSGS/100)))
+  if (0 == (n % (TOTAL_MSGS / 100)))
     fprintf (stderr, ".");
   if (n == TOTAL_MSGS)
-    {
-      GNUNET_SCHEDULER_cancel (err_task);
-      GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
-    }
+  {
+    GNUNET_SCHEDULER_cancel (err_task);
+    GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
+  }
   else
-    {
-      if (n == tr_n)
-        GNUNET_break (NULL != 
-                      GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                         GNUNET_NO,
-                                                         0,
-                                                         FAST_TIMEOUT,
-                                                         &p2.id,
-                                                         get_size(tr_n),
-                                                         &transmit_ready, &p1));
-    }
+  {
+    if (n == tr_n)
+      GNUNET_break (NULL !=
+                    GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                       GNUNET_NO,
+                                                       0,
+                                                       FAST_TIMEOUT,
+                                                       &p2.id,
+                                                       get_size (tr_n),
+                                                       &transmit_ready, &p1));
+  }
   return GNUNET_OK;
 }
 
@@ -407,44 +390,39 @@ init_notify (void *cls,
   p->id = *my_identity;
   p->ch = server;
   if (cls == &p1)
-    {
-      GNUNET_assert (ok == 2);
-      OKPP;
-      /* connect p2 */
-      GNUNET_CORE_connect (p2.cfg, 1,
-                           &p2,
-                           &init_notify,                         
-                           &connect_notify,
-                           &disconnect_notify,
-                           NULL,
-                           &inbound_notify,
-                           GNUNET_YES,
-                           &outbound_notify, GNUNET_YES, handlers);
-    }
+  {
+    GNUNET_assert (ok == 2);
+    OKPP;
+    /* connect p2 */
+    GNUNET_CORE_connect (p2.cfg, 1,
+                         &p2,
+                         &init_notify,
+                         &connect_notify,
+                         &disconnect_notify,
+                         NULL,
+                         &inbound_notify,
+                         GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
+  }
   else
-    {
-      GNUNET_assert (ok == 3);
-      OKPP;
-      GNUNET_assert (cls == &p2);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Asking core (1) to connect to peer `%4s'\n",
-                  GNUNET_i2s (&p2.id));
-      GNUNET_CORE_peer_request_connect (p1.ch,
-                                        &p2.id,
-                                        NULL, NULL);
-    }
+  {
+    GNUNET_assert (ok == 3);
+    OKPP;
+    GNUNET_assert (cls == &p2);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Asking core (1) to connect to peer `%4s'\n",
+                GNUNET_i2s (&p2.id));
+    GNUNET_CORE_peer_request_connect (p1.ch, &p2.id, NULL, 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_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received (my) `%s' from transport service\n",
-              "HELLO");
+              "Received (my) `%s' from transport service\n", "HELLO");
   GNUNET_assert (message != NULL);
   p->hello = GNUNET_malloc (ntohs (message->size));
   memcpy (p->hello, message, ntohs (message->size));
@@ -467,11 +445,11 @@ 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, NULL, NULL);
@@ -483,23 +461,20 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 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);
   OKPP;
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
-  err_task = 
-    GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                  &terminate_task_error, 
-                                  NULL);
+  err_task =
+      GNUNET_SCHEDULER_add_delayed (TIMEOUT, &terminate_task_error, NULL);
   GNUNET_CORE_connect (p1.cfg, 1,
                        &p1,
                        &init_notify,
-                       &connect_notify,
+                       &connect_notify,
                        &disconnect_notify,
-                       NULL,
+                       NULL,
                        &inbound_notify,
                        GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
 }
@@ -511,10 +486,11 @@ stop_arm (struct PeerContext *p)
 #if START_ARM
   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
@@ -537,7 +513,8 @@ check ()
   };
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-core-api-reliability", "nohelp", options, &run, &ok);
+                      argv, "test-core-api-reliability", "nohelp", options,
+                      &run, &ok);
   stop_arm (&p1);
   stop_arm (&p2);
   return ok;
@@ -556,7 +533,7 @@ main (int argc, char *argv[])
 #endif
                     NULL);
   ret = check ();
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1"); 
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");
 
   return ret;
diff --git a/src/core/test_core_api_send_to_self.c b/src/core/test_core_api_send_to_self.c
index f2ddeb9fe..09d6edacc 100644
--- a/src/core/test_core_api_send_to_self.c
+++ b/src/core/test_core_api_send_to_self.c
@@ -66,18 +66,17 @@ cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tskctx)
   die_task = GNUNET_SCHEDULER_NO_TASK;
 
   if (core != NULL)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting core.\n");
-      GNUNET_CORE_disconnect (core);
-      core = NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting core.\n");
+    GNUNET_CORE_disconnect (core);
+    core = NULL;
+  }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Stopping peer\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peer\n");
   if (0 != GNUNET_OS_process_kill (arm_proc, SIGTERM))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 
-  if (GNUNET_OS_process_wait(arm_proc) != GNUNET_OK)
+  if (GNUNET_OS_process_wait (arm_proc) != GNUNET_OK)
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -85,33 +84,37 @@ cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tskctx)
   GNUNET_OS_process_close (arm_proc);
   arm_proc = NULL;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ending test.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending test.\n");
 }
 
 static int
-receive(void* cls, const struct GNUNET_PeerIdentity* other, const struct GNUNET_MessageHeader* message, const struct GNUNET_TRANSPORT_ATS_Information* atsi)
+receive (void *cls, const struct GNUNET_PeerIdentity *other,
+         const struct GNUNET_MessageHeader *message,
+         const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   if (die_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(die_task);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received message from peer %s\n", GNUNET_i2s(other));
-  GNUNET_SCHEDULER_add_now(&cleanup, NULL);
+    GNUNET_SCHEDULER_cancel (die_task);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message from peer %s\n",
+              GNUNET_i2s (other));
+  GNUNET_SCHEDULER_add_now (&cleanup, NULL);
   ret = 0;
   return GNUNET_OK;
 }
 
 static size_t
-send_message (void* cls, size_t size, void* buf)
+send_message (void *cls, size_t size, void *buf)
 {
   if (size == 0 || buf == NULL)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Could not send; got 0 buffer\n");
-      return 0;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending!\n");
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Could not send; got 0 buffer\n");
+    return 0;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending!\n");
   struct GNUNET_MessageHeader *hdr = buf;
-  hdr->size = htons(sizeof(struct GNUNET_MessageHeader));
-  hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP);
-  return ntohs(hdr->size);
+
+  hdr->size = htons (sizeof (struct GNUNET_MessageHeader));
+  hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP);
+  return ntohs (hdr->size);
 }
 
 static void
@@ -120,33 +123,33 @@ init (void *cls, struct GNUNET_CORE_Handle *core,
       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pk)
 {
   if (core == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Could NOT connect to CORE;\n");
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Could NOT connect to CORE;\n");
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Correctly connected to CORE; we are the peer %s.\n",
-              GNUNET_i2s (my_identity));
+              "Correctly connected to CORE; we are the peer %s.\n",
+              GNUNET_i2s (my_identity));
   memcpy (&myself, my_identity, sizeof (struct GNUNET_PeerIdentity));
 }
 
 static void
 connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer,
-            const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+            const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected to peer %s.\n",
-              GNUNET_i2s (peer));
+              GNUNET_i2s (peer));
   if (0 == memcmp (peer, &myself, sizeof (struct GNUNET_PeerIdentity)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connected to myself; sending message!\n");
-      GNUNET_CORE_notify_transmit_ready (core,
-                                         GNUNET_YES,
-                                         0, GNUNET_TIME_UNIT_FOREVER_REL,
-                                         peer,
-                                         sizeof (struct GNUNET_MessageHeader),
-                                         send_message, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connected to myself; sending message!\n");
+    GNUNET_CORE_notify_transmit_ready (core,
+                                       GNUNET_YES,
+                                       0, GNUNET_TIME_UNIT_FOREVER_REL,
+                                       peer,
+                                       sizeof (struct GNUNET_MessageHeader),
+                                       send_message, NULL);
+  }
 }
 
 
@@ -161,8 +164,7 @@ connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer,
 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)
 {
   const static struct GNUNET_CORE_MessageHandler handlers[] = {
     {&receive, GNUNET_MESSAGE_TYPE_VPN_SERVICE_UDP, 0},
@@ -172,22 +174,27 @@ run (void *cls,
   core_cfg = GNUNET_CONFIGURATION_create ();
 
   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", "test_core_api_peer1.conf", NULL);
+                                      "-c", "test_core_api_peer1.conf", NULL);
 
-  GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_load (core_cfg, "test_core_api_peer1.conf"));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (core_cfg,
+                                            "test_core_api_peer1.conf"));
 
   core = GNUNET_CORE_connect (core_cfg,
-                              42,
-                              NULL,
-                              &init,
-                              &connect_cb,
-                              NULL, NULL, NULL, 0, NULL, 0, handlers);
-
-  die_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60), &cleanup, cls);
+                              42,
+                              NULL,
+                              &init,
+                              &connect_cb,
+                              NULL, NULL, NULL, 0, NULL, 0, handlers);
+
+  die_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_SECONDS, 60), &cleanup,
+                                    cls);
 }
 
 
@@ -210,11 +217,11 @@ check ()
   ret = 1;
 
   return (GNUNET_OK ==
-          GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                              argv,
-                              "test_core_api_send_to_self",
-                              gettext_noop ("help text"),
-                              options, &run, NULL)) ? ret : 1;
+          GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
+                              argv,
+                              "test_core_api_send_to_self",
+                              gettext_noop ("help text"),
+                              options, &run, NULL)) ? ret : 1;
 }
 
 /**
diff --git a/src/core/test_core_api_start_only.c b/src/core/test_core_api_start_only.c
index b6ad19b77..36d964796 100644
--- a/src/core/test_core_api_start_only.c
+++ b/src/core/test_core_api_start_only.c
@@ -68,14 +68,13 @@ static int ok;
 static void
 connect_notify (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
 }
 
 
 static void
-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
 }
 
@@ -84,7 +83,7 @@ static int
 inbound_notify (void *cls,
                 const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   return GNUNET_OK;
 }
@@ -94,7 +93,7 @@ static int
 outbound_notify (void *cls,
                  const struct GNUNET_PeerIdentity *other,
                  const struct GNUNET_MessageHeader *message,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   return GNUNET_OK;
 }
@@ -106,8 +105,7 @@ static struct GNUNET_CORE_MessageHandler handlers[] = {
 
 
 static void
-shutdown_task (void *cls, 
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_CORE_disconnect (p1.ch);
   p1.ch = NULL;
@@ -130,24 +128,24 @@ init_notify (void *cls,
   GNUNET_assert (server != NULL);
   GNUNET_assert (p->ch == server);
   if (cls == &p1)
-    {
-      /* connect p2 */
-      p2.ch = GNUNET_CORE_connect (p2.cfg, 1,
-                                   &p2,
-                                   &init_notify,                         
-                                   &connect_notify,
-                                   &disconnect_notify,
-                                   NULL,
-                                   &inbound_notify,
-                                   GNUNET_YES,
-                                   &outbound_notify, GNUNET_YES, handlers);
-    }
+  {
+    /* connect p2 */
+    p2.ch = GNUNET_CORE_connect (p2.cfg, 1,
+                                 &p2,
+                                 &init_notify,
+                                 &connect_notify,
+                                 &disconnect_notify,
+                                 NULL,
+                                 &inbound_notify,
+                                 GNUNET_YES,
+                                 &outbound_notify, GNUNET_YES, handlers);
+  }
   else
-    {
-      GNUNET_assert (cls == &p2);
-      GNUNET_SCHEDULER_cancel (timeout_task_id);
-      GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
-    }
+  {
+    GNUNET_assert (cls == &p2);
+    GNUNET_SCHEDULER_cancel (timeout_task_id);
+    GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
+  }
 }
 
 
@@ -157,31 +155,30 @@ 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));
 }
 
 
 static void
-timeout_task (void *cls, 
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   fprintf (stderr, "Timeout.\n");
   if (p1.ch != NULL)
-    {
-      GNUNET_CORE_disconnect (p1.ch);
-      p1.ch = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (p1.ch);
+    p1.ch = NULL;
+  }
   if (p2.ch != NULL)
-    {
-      GNUNET_CORE_disconnect (p2.ch);
-      p2.ch = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (p2.ch);
+    p2.ch = NULL;
+  }
   ok = 42;
 }
 
@@ -190,39 +187,35 @@ timeout_task (void *cls,
 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);
   OKPP;
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
-  timeout_task_id = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, TIMEOUT),
-                                                  &timeout_task,
-                                                  NULL);
-  p1.ch = GNUNET_CORE_connect (p1.cfg, 1,
-                               &p1,
-                               &init_notify,
-                               &connect_notify,
-                               &disconnect_notify,
-                               NULL,
-                               &inbound_notify,
-                               GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
+  timeout_task_id =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MINUTES, TIMEOUT),
+                                    &timeout_task, NULL);
+  p1.ch =
+      GNUNET_CORE_connect (p1.cfg, 1, &p1, &init_notify, &connect_notify,
+                           &disconnect_notify, NULL, &inbound_notify,
+                           GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
 }
 
 
 static void
 stop_arm (struct PeerContext *p)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Stopping peer\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peer\n");
 #if START_ARM
   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
@@ -249,9 +242,9 @@ check ()
 
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-core-api-start-only", "nohelp", options, &run, &ok);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Test finished\n");
+                      argv, "test-core-api-start-only", "nohelp", options, &run,
+                      &ok);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test finished\n");
   stop_arm (&p1);
   stop_arm (&p2);
   return ok;
diff --git a/src/core/test_core_quota_compliance.c b/src/core/test_core_quota_compliance.c
index 03a7c62eb..5dcc20597 100644
--- a/src/core/test_core_quota_compliance.c
+++ b/src/core/test_core_quota_compliance.c
@@ -77,7 +77,7 @@ struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;
-  struct GNUNET_PeerIdentity id;   
+  struct GNUNET_PeerIdentity id;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
   struct GNUNET_STATISTICS_Handle *stats;
@@ -108,13 +108,14 @@ static int running;
 #define OKPP do { ok++; } while (0)
 #endif
 
-struct TestMessage 
+struct TestMessage
 {
   struct GNUNET_MessageHeader header;
   uint32_t num;
 };
 
-static void process_hello (void *cls, const struct GNUNET_MessageHeader *message);
+static void process_hello (void *cls,
+                           const struct GNUNET_MessageHeader *message);
 
 static void
 terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
@@ -140,11 +141,11 @@ static void
 terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase failed!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase failed!\n");
   //GNUNET_break (0);
 
   if (measure_task != GNUNET_SCHEDULER_NO_TASK)
-          GNUNET_SCHEDULER_cancel(measure_task);
+    GNUNET_SCHEDULER_cancel (measure_task);
 
   GNUNET_TRANSPORT_get_hello_cancel (p1.th, &process_hello, &p1);
   GNUNET_TRANSPORT_get_hello_cancel (p2.th, &process_hello, &p2);
@@ -173,21 +174,15 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 static int
 print_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)
 {
-  if (cls==&p1)
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-           "Peer1 %50s = %12llu\n",
-           name,
-           (unsigned long long) value);
-  if (cls==&p2)
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                   "Peer2 %50s = %12llu\n",
-                   name,
-                   (unsigned long long) value);
+  if (cls == &p1)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer1 %50s = %12llu\n", name, (unsigned long long) value);
+  if (cls == &p2)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer2 %50s = %12llu\n", name, (unsigned long long) value);
   return GNUNET_OK;
 }
 
@@ -202,7 +197,7 @@ measurement_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   unsigned long long int quota_delta;
 
   measure_task = GNUNET_SCHEDULER_NO_TASK;
-  fprintf(stdout,"\n");
+  fprintf (stdout, "\n");
   running = GNUNET_NO;
 
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
@@ -211,96 +206,91 @@ measurement_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   throughput_in = total_bytes_recv * 1000 / 1024 / delta;
 
   if (current_quota_p1_in < current_quota_p2_in)
-          max_quota_in = current_quota_p1_in;
+    max_quota_in = current_quota_p1_in;
   else
-          max_quota_in = current_quota_p2_in;
+    max_quota_in = current_quota_p2_in;
   if (current_quota_p1_out < current_quota_p2_out)
-          max_quota_out = current_quota_p1_out;
+    max_quota_out = current_quota_p1_out;
   else
-          max_quota_out = current_quota_p2_out;
+    max_quota_out = current_quota_p2_out;
 
   if (max_quota_out < max_quota_in)
-          quota_delta = max_quota_in / 10;
+    quota_delta = max_quota_in / 10;
   else
-          quota_delta = max_quota_out / 10;
+    quota_delta = max_quota_out / 10;
 
-  if ((throughput_out > (max_quota_out+quota_delta)/1024) || (throughput_in > (max_quota_in+quota_delta)/1024))
-          ok = 1;
+  if ((throughput_out > (max_quota_out + quota_delta) / 1024) ||
+      (throughput_in > (max_quota_in + quota_delta) / 1024))
+    ok = 1;
   else
-          ok = 0;
+    ok = 0;
 
   GNUNET_STATISTICS_get (p1.stats,
-                     "core",
-                     "# discarded CORE_SEND requests",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, &p1);
+                         "core",
+                         "# discarded CORE_SEND requests",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p1);
 
   GNUNET_STATISTICS_get (p1.stats,
-                     "core",
-                     "# discarded CORE_SEND request bytes",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, &p1);
+                         "core",
+                         "# discarded CORE_SEND request bytes",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p1);
   GNUNET_STATISTICS_get (p1.stats,
-                     "core",
-                     "# discarded lower priority CORE_SEND requests",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, NULL);
+                         "core",
+                         "# discarded lower priority CORE_SEND requests",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, NULL);
   GNUNET_STATISTICS_get (p1.stats,
-                     "core",
-                     "# discarded lower priority CORE_SEND request bytes",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, &p1);
+                         "core",
+                         "# discarded lower priority CORE_SEND request bytes",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p1);
   GNUNET_STATISTICS_get (p2.stats,
-                     "core",
-                     "# discarded CORE_SEND requests",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, &p2);
+                         "core",
+                         "# discarded CORE_SEND requests",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
 
   GNUNET_STATISTICS_get (p2.stats,
-                     "core",
-                     "# discarded CORE_SEND request bytes",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, &p2);
+                         "core",
+                         "# discarded CORE_SEND request bytes",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
   GNUNET_STATISTICS_get (p2.stats,
-                     "core",
-                     "# discarded lower priority CORE_SEND requests",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, &p2);
+                         "core",
+                         "# discarded lower priority CORE_SEND requests",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
   GNUNET_STATISTICS_get (p2.stats,
-                     "core",
-                     "# discarded lower priority CORE_SEND request bytes",
-                     GNUNET_TIME_UNIT_FOREVER_REL,
-                     NULL,
-                     &print_stat, &p2);
+                         "core",
+                         "# discarded lower priority CORE_SEND request bytes",
+                         GNUNET_TIME_UNIT_FOREVER_REL, NULL, &print_stat, &p2);
 
   enum GNUNET_ErrorType kind = GNUNET_ERROR_TYPE_DEBUG;
-  if (ok==1)
+
+  if (ok == 1)
   {
-          kind = GNUNET_ERROR_TYPE_ERROR;
+    kind = GNUNET_ERROR_TYPE_ERROR;
   }
   switch (test)
   {
   case SYMMETRIC:
-          GNUNET_log (kind,"Core quota compliance test with symmetric quotas: %s\n", (ok==0)?"PASSED":"FAILED");
-          break;
+    GNUNET_log (kind, "Core quota compliance test with symmetric quotas: %s\n",
+                (ok == 0) ? "PASSED" : "FAILED");
+    break;
   case ASYMMETRIC_SEND_LIMITED:
-          GNUNET_log (kind,"Core quota compliance test with limited sender quota: %s\n", (ok==0)?"PASSED":"FAILED");
-          break;
+    GNUNET_log (kind,
+                "Core quota compliance test with limited sender quota: %s\n",
+                (ok == 0) ? "PASSED" : "FAILED");
+    break;
   case ASYMMETRIC_RECV_LIMITED:
-          GNUNET_log (kind,"Core quota compliance test with limited receiver quota: %s\n", (ok==0)?"PASSED":"FAILED");
-          break;
+    GNUNET_log (kind,
+                "Core quota compliance test with limited receiver quota: %s\n",
+                (ok == 0) ? "PASSED" : "FAILED");
+    break;
   };
-  GNUNET_log (kind,"Peer 1 send  rate: %llu kB/s (%llu Bytes in %u sec.)\n",throughput_out,total_bytes_sent, delta/1000);
-  GNUNET_log (kind,"Peer 1 send quota: %llu kB/s\n",current_quota_p1_out / 1024);
-  GNUNET_log (kind,"Peer 2 receive  rate: %llu kB/s (%llu Bytes in %u sec.)\n",throughput_in,total_bytes_recv, delta/1000);
-  GNUNET_log (kind,"Peer 2 receive quota: %llu kB/s\n",current_quota_p2_in / 1024);
+  GNUNET_log (kind, "Peer 1 send  rate: %llu kB/s (%llu Bytes in %u sec.)\n",
+              throughput_out, total_bytes_sent, delta / 1000);
+  GNUNET_log (kind, "Peer 1 send quota: %llu kB/s\n",
+              current_quota_p1_out / 1024);
+  GNUNET_log (kind, "Peer 2 receive  rate: %llu kB/s (%llu Bytes in %u sec.)\n",
+              throughput_in, total_bytes_recv, delta / 1000);
+  GNUNET_log (kind, "Peer 2 receive quota: %llu kB/s\n",
+              current_quota_p2_in / 1024);
 /*
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Max. inbound  quota allowed: %llu kB/s\n",max_quota_in /1024);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Max. outbound quota allowed: %llu kB/s\n",max_quota_out/1024);
@@ -319,49 +309,45 @@ transmit_ready (void *cls, size_t size, void *buf)
 
   GNUNET_assert (size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE);
   if (buf == NULL)
-    {
-      if ( (p1.ch != NULL) &&
-           (p1.connect_status == 1) )
-        GNUNET_break (NULL !=
-                      GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                         GNUNET_NO,
-                                                         0,
-                                                         FAST_TIMEOUT,
-                                                         &p2.id,
-                                                         MESSAGESIZE,
-                                                         &transmit_ready, &p1));
-      return 0;
-    }
+  {
+    if ((p1.ch != NULL) && (p1.connect_status == 1))
+      GNUNET_break (NULL !=
+                    GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                       GNUNET_NO,
+                                                       0,
+                                                       FAST_TIMEOUT,
+                                                       &p2.id,
+                                                       MESSAGESIZE,
+                                                       &transmit_ready, &p1));
+    return 0;
+  }
   GNUNET_assert (tr_n < TOTAL_MSGS);
   ret = 0;
   GNUNET_assert (size >= MESSAGESIZE);
   GNUNET_assert (buf != NULL);
   cbuf = buf;
   do
-    {
+  {
 #if DEBUG_TRANSMISSION
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending message %u of size %u at offset %u\n",
-                  tr_n,
-                  MESSAGESIZE,
-                  ret);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending message %u of size %u at offset %u\n",
+                tr_n, MESSAGESIZE, ret);
 #endif
-      hdr.header.size = htons (MESSAGESIZE);
-      hdr.header.type = htons (MTYPE);
-      hdr.num = htonl (tr_n);
-      memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
-      ret += sizeof (struct TestMessage);
-      memset (&cbuf[ret], tr_n, MESSAGESIZE - sizeof (struct TestMessage));
-      ret += MESSAGESIZE - sizeof (struct TestMessage);
-      tr_n++;
-      if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
-        break; /* sometimes pack buffer full, sometimes not */
-    }
+    hdr.header.size = htons (MESSAGESIZE);
+    hdr.header.type = htons (MTYPE);
+    hdr.num = htonl (tr_n);
+    memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+    ret += sizeof (struct TestMessage);
+    memset (&cbuf[ret], tr_n, MESSAGESIZE - sizeof (struct TestMessage));
+    ret += MESSAGESIZE - sizeof (struct TestMessage);
+    tr_n++;
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+      break;                    /* sometimes pack buffer full, sometimes not */
+  }
   while (size - ret >= MESSAGESIZE);
   GNUNET_SCHEDULER_cancel (err_task);
   err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                  &terminate_task_error,
-                                  NULL);
+                                           &terminate_task_error, NULL);
 
   total_bytes_sent += ret;
   return ret;
@@ -376,50 +362,48 @@ connect_notify (void *cls,
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   GNUNET_assert (pc->connect_status == 0);
   pc->connect_status = 1;
   if (pc == &p1)
-    {
+  {
 #if DEBUG_TRANSMISSION
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Encrypted connection established to peer `%4s'\n",
-                  GNUNET_i2s (peer));
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Asking core (1) for transmission to peer `%4s'\n",
-                  GNUNET_i2s (&p2.id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Encrypted connection established to peer `%4s'\n",
+                GNUNET_i2s (peer));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Asking core (1) for transmission to peer `%4s'\n",
+                GNUNET_i2s (&p2.id));
 #endif
-      if (err_task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (err_task);
-      err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                      &terminate_task_error,
-                                      NULL);
-      start_time = GNUNET_TIME_absolute_get ();
-      running = GNUNET_YES;
-      measure_task = GNUNET_SCHEDULER_add_delayed(MEASUREMENT_LENGTH, &measurement_stop, NULL);
-
-      GNUNET_break (NULL != GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                               GNUNET_NO,
-                                                               0,
-                                                               TIMEOUT,
-                                                               &p2.id,
-                                                               MESSAGESIZE,
-                                                               &transmit_ready, &p1));
-    }
+    if (err_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (err_task);
+    err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                             &terminate_task_error, NULL);
+    start_time = GNUNET_TIME_absolute_get ();
+    running = GNUNET_YES;
+    measure_task =
+        GNUNET_SCHEDULER_add_delayed (MEASUREMENT_LENGTH, &measurement_stop,
+                                      NULL);
+
+    GNUNET_break (NULL != GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                             GNUNET_NO,
+                                                             0,
+                                                             TIMEOUT,
+                                                             &p2.id,
+                                                             MESSAGESIZE,
+                                                             &transmit_ready,
+                                                             &p1));
+  }
 }
 
 
 static void
-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *pc = cls;
 
-  if (0 == memcmp (&pc->id,
-                   peer,
-                   sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
   pc->connect_status = 0;
 #if DEBUG_TRANSMISSION
@@ -433,13 +417,14 @@ static int
 inbound_notify (void *cls,
                 const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
 #if DEBUG_TRANSMISSION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Core provides inbound data from `%4s' %llu.\n", GNUNET_i2s (other), ntohs(message->size));
+              "Core provides inbound data from `%4s' %llu.\n",
+              GNUNET_i2s (other), ntohs (message->size));
 #endif
-  total_bytes_recv += ntohs(message->size);
+  total_bytes_recv += ntohs (message->size);
   return GNUNET_OK;
 }
 
@@ -448,7 +433,7 @@ static int
 outbound_notify (void *cls,
                  const struct GNUNET_PeerIdentity *other,
                  const struct GNUNET_MessageHeader *message,
-                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
 #if DEBUG_TRANSMISSION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -459,48 +444,42 @@ outbound_notify (void *cls,
 }
 
 
-static size_t
-transmit_ready (void *cls, size_t size, void *buf);
+static size_t transmit_ready (void *cls, size_t size, void *buf);
 
 static int
 process_mtype (void *cls,
                const struct GNUNET_PeerIdentity *peer,
                const struct GNUNET_MessageHeader *message,
-               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   static int n;
   const struct TestMessage *hdr;
 
-  hdr = (const struct TestMessage*) message;
+  hdr = (const struct TestMessage *) message;
   if (MTYPE != ntohs (message->type))
     return GNUNET_SYSERR;
   if (ntohs (message->size) != MESSAGESIZE)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, MESSAGESIZE,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      GNUNET_SCHEDULER_cancel (err_task);
-      err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, MESSAGESIZE, ntohs (message->size), ntohl (hdr->num));
+    GNUNET_SCHEDULER_cancel (err_task);
+    err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
+    return GNUNET_SYSERR;
+  }
   if (ntohl (hdr->num) != n)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, MESSAGESIZE,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      GNUNET_SCHEDULER_cancel (err_task);
-      err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, MESSAGESIZE, ntohs (message->size), ntohl (hdr->num));
+    GNUNET_SCHEDULER_cancel (err_task);
+    err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_TRANSMISSION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got message %u of size %u\n",
-              ntohl (hdr->num),
-              ntohs (message->size));         
+              "Got message %u of size %u\n",
+              ntohl (hdr->num), ntohs (message->size));
 #endif
   n++;
   if (0 == (n % 10))
@@ -508,14 +487,14 @@ process_mtype (void *cls,
 
 
   if (running == GNUNET_YES)
-        GNUNET_break (NULL !=
-                      GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                                         GNUNET_NO,
-                                                         0,
-                                                         FAST_TIMEOUT,
-                                                         &p2.id,
-                                                         MESSAGESIZE,
-                                                         &transmit_ready, &p1));
+    GNUNET_break (NULL !=
+                  GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                     GNUNET_NO,
+                                                     0,
+                                                     FAST_TIMEOUT,
+                                                     &p2.id,
+                                                     MESSAGESIZE,
+                                                     &transmit_ready, &p1));
   return GNUNET_OK;
 }
 
@@ -542,48 +521,43 @@ init_notify (void *cls,
   p->id = *my_identity;
   p->ch = server;
   if (cls == &p1)
-    {
-      GNUNET_assert (ok == 2);
-      OKPP;
-      /* connect p2 */
-      GNUNET_CORE_connect (p2.cfg, 1,
-                           &p2,
-                           &init_notify,                         
-                           &connect_notify,
-                           &disconnect_notify,
-                           NULL,
-                           &inbound_notify,
-                           GNUNET_YES,
-                           &outbound_notify, GNUNET_YES, handlers);
-    }
+  {
+    GNUNET_assert (ok == 2);
+    OKPP;
+    /* connect p2 */
+    GNUNET_CORE_connect (p2.cfg, 1,
+                         &p2,
+                         &init_notify,
+                         &connect_notify,
+                         &disconnect_notify,
+                         NULL,
+                         &inbound_notify,
+                         GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
+  }
   else
-    {
-      GNUNET_assert (ok == 3);
-      OKPP;
-      GNUNET_assert (cls == &p2);
+  {
+    GNUNET_assert (ok == 3);
+    OKPP;
+    GNUNET_assert (cls == &p2);
 #if DEBUG_TRANSMISSION
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Asking core (1) to connect to peer `%4s'\n",
-                  GNUNET_i2s (&p2.id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Asking core (1) to connect to peer `%4s'\n",
+                GNUNET_i2s (&p2.id));
 #endif
-      GNUNET_CORE_peer_request_connect (p1.ch,
-                                        &p2.id,
-                                        NULL, NULL);
-    }
+    GNUNET_CORE_peer_request_connect (p1.ch, &p2.id, NULL, 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;
 
 
 #if DEBUG_TRANSMISSION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received (my) `%s' from transport service\n",
-              "HELLO");
+              "Received (my) `%s' from transport service\n", "HELLO");
 #endif
   GNUNET_assert (message != NULL);
   p->hello = GNUNET_malloc (ntohs (message->size));
@@ -607,15 +581,15 @@ 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->stats = GNUNET_STATISTICS_create ("core",p->cfg);
-  GNUNET_assert (p->stats!=NULL);
+  p->stats = GNUNET_STATISTICS_create ("core", p->cfg);
+  GNUNET_assert (p->stats != NULL);
   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
   GNUNET_assert (p->th != NULL);
   GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
@@ -625,47 +599,45 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 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);
   OKPP;
   err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                              &terminate_task_error,
-                              NULL);
+                                           &terminate_task_error, NULL);
   if (test == SYMMETRIC)
-    {
-      setup_peer (&p1, "test_core_quota_peer1.conf");
-      setup_peer (&p2, "test_core_quota_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_core_quota_peer1.conf");
+    setup_peer (&p2, "test_core_quota_peer2.conf");
+  }
   else if (test == ASYMMETRIC_SEND_LIMITED)
-    {
-      setup_peer (&p1, "test_core_quota_asymmetric_send_limit_peer1.conf");
-      setup_peer (&p2, "test_core_quota_asymmetric_send_limit_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_core_quota_asymmetric_send_limit_peer1.conf");
+    setup_peer (&p2, "test_core_quota_asymmetric_send_limit_peer2.conf");
+  }
   else if (test == ASYMMETRIC_RECV_LIMITED)
-    {
-      setup_peer (&p1, "test_core_quota_asymmetric_recv_limited_peer1.conf");
-      setup_peer (&p2, "test_core_quota_asymmetric_recv_limited_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_core_quota_asymmetric_recv_limited_peer1.conf");
+    setup_peer (&p2, "test_core_quota_asymmetric_recv_limited_peer2.conf");
+  }
 
   GNUNET_assert (test != -1);
   GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p1.cfg,
-                                         "CORE",
-                                         "TOTAL_QUOTA_IN",
-                                         &current_quota_p1_in));
+                                                                         "CORE",
+                                                                         "TOTAL_QUOTA_IN",
+                                                                         &current_quota_p1_in));
   GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p2.cfg,
-                                         "CORE",
-                                         "TOTAL_QUOTA_IN",
-                                         &current_quota_p2_in));
+                                                                         "CORE",
+                                                                         "TOTAL_QUOTA_IN",
+                                                                         &current_quota_p2_in));
   GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p1.cfg,
-                                         "CORE",
-                                         "TOTAL_QUOTA_OUT",
-                                         &current_quota_p1_out));
+                                                                         "CORE",
+                                                                         "TOTAL_QUOTA_OUT",
+                                                                         &current_quota_p1_out));
   GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p2.cfg,
-                                         "CORE",
-                                         "TOTAL_QUOTA_OUT",
-                                         &current_quota_p2_out));
+                                                                         "CORE",
+                                                                         "TOTAL_QUOTA_OUT",
+                                                                         &current_quota_p2_out));
 
   GNUNET_CORE_connect (p1.cfg, 1,
                        &p1,
@@ -684,10 +656,11 @@ stop_arm (struct PeerContext *p)
 #if START_ARM
   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
@@ -712,7 +685,8 @@ check ()
   };
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-core-quota-compliance", "nohelp", options, &run, &ok);
+                      argv, "test-core-quota-compliance", "nohelp", options,
+                      &run, &ok);
   stop_arm (&p1);
   stop_arm (&p2);
   return ok;
@@ -724,34 +698,38 @@ main (int argc, char *argv[])
   int ret;
 
   test = -1;
-  if (strstr(argv[0], "_symmetric") != NULL)
-    {
-      test = SYMMETRIC;
-    }
-  else if (strstr(argv[0], "_asymmetric_send") != NULL)
-    {
-          test = ASYMMETRIC_SEND_LIMITED;
-    }
-  else if (strstr(argv[0], "_asymmetric_recv") != NULL)
-    {
-          test = ASYMMETRIC_RECV_LIMITED;
-    }
+  if (strstr (argv[0], "_symmetric") != NULL)
+  {
+    test = SYMMETRIC;
+  }
+  else if (strstr (argv[0], "_asymmetric_send") != NULL)
+  {
+    test = ASYMMETRIC_SEND_LIMITED;
+  }
+  else if (strstr (argv[0], "_asymmetric_recv") != NULL)
+  {
+    test = ASYMMETRIC_RECV_LIMITED;
+  }
   GNUNET_assert (test != -1);
   if (test == SYMMETRIC)
-    {
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-1/");
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-2/");
-    }
+  {
+    GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-1/");
+    GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-2/");
+  }
   else if (test == ASYMMETRIC_SEND_LIMITED)
-    {
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-1/");
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-2/");
-    }
+  {
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-1/");
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-2/");
+  }
   else if (test == ASYMMETRIC_RECV_LIMITED)
-    {
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-1/");
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-2/");
-    }
+  {
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-1/");
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-2/");
+  }
 
   GNUNET_log_setup ("test-core-quota-compliance",
 #if VERBOSE
@@ -762,23 +740,28 @@ main (int argc, char *argv[])
                     NULL);
   ret = check ();
   if (test == SYMMETRIC)
-    {
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-1/");
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-2/");
-    }
+  {
+    GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-1/");
+    GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-2/");
+  }
   else if (test == ASYMMETRIC_SEND_LIMITED)
-    {
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-1/");
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-2/");
-    }
+  {
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-1/");
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-2/");
+  }
   else if (test == ASYMMETRIC_RECV_LIMITED)
-    {
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-1/");
-          GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-2/");
-    }
+  {
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-1/");
+    GNUNET_DISK_directory_remove
+        ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-2/");
+  }
 
 
 
   return ret;
 }
+
 /* end of test_core_api_reliability.c */