global reindent, now with uncrustify hook enabled

41 files changed, 10691 insertions, 10058 deletions

diff --git a/src/ats/ats.h b/src/ats/ats.h
index 3501860f3..3a3d12cfa 100644
--- a/src/ats/ats.h
+++ b/src/ats/ats.h
@@ -34,7 +34,8 @@
  * Flag used to indicate which type of client is connecting
  * to the ATS service.
  */
-enum StartFlag {
+enum StartFlag
+{
   /**
    * This is a scheduling client (aka transport service)
    */
@@ -65,7 +66,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * First message any client sends to ATS, used to self-identify
  * (what type of client this is).
  */
-struct ClientStartMessage {
+struct ClientStartMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_START.
    */
@@ -82,7 +84,8 @@ struct ClientStartMessage {
  * Connectivity client to ATS service: we would like to have
  * address suggestions for this peer.
  */
-struct RequestAddressMessage {
+struct RequestAddressMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS or
    * #GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL to stop
@@ -105,7 +108,8 @@ struct RequestAddressMessage {
 /**
  * Scheduling client to ATS service: here is another address you can use.
  */
-struct AddressAddMessage {
+struct AddressAddMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD.
    */
@@ -154,7 +158,8 @@ struct AddressAddMessage {
  * Message used to notify ATS that the performance
  * characteristics for an address have changed.
  */
-struct AddressUpdateMessage {
+struct AddressUpdateMessage
+{
   /**
    * Message of type #GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE.
    */
@@ -184,7 +189,8 @@ struct AddressUpdateMessage {
  * was destroyed and must thus henceforth no longer be considered
  * for scheduling.
  */
-struct AddressDestroyedMessage {
+struct AddressDestroyedMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED.
    */
@@ -208,7 +214,8 @@ struct AddressDestroyedMessage {
  * Message sent by ATS service to client to confirm that it is done
  * using the given session ID.
  */
-struct GNUNET_ATS_SessionReleaseMessage {
+struct GNUNET_ATS_SessionReleaseMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE.
    */
@@ -234,7 +241,8 @@ struct GNUNET_ATS_SessionReleaseMessage {
  * identified by the given @e session_id for the given @e peer with
  * the given @e bandwidth_in and @e bandwidth_out limits from now on.
  */
-struct AddressSuggestionMessage {
+struct AddressSuggestionMessage
+{
   /**
    * A message of type #GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION.
    */
@@ -268,7 +276,8 @@ struct AddressSuggestionMessage {
 /**
  *
  */
-struct PeerInformationMessage {
+struct PeerInformationMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION
    */
@@ -330,7 +339,8 @@ struct PeerInformationMessage {
 /**
  * Client to service: please give us an overview of the addresses.
  */
-struct AddressListRequestMessage {
+struct AddressListRequestMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST
    */
@@ -357,7 +367,8 @@ struct AddressListRequestMessage {
 /**
  *
  */
-struct ReservationRequestMessage {
+struct ReservationRequestMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST
    */
@@ -378,7 +389,8 @@ struct ReservationRequestMessage {
 /**
  *
  */
-struct ReservationResultMessage {
+struct ReservationResultMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT
    */
@@ -405,7 +417,8 @@ struct ReservationResultMessage {
  * Variable-size entry in a `struct ChangePreferenceMessage` or
  * `struct FeedbackPreferenceMessage`.
  */
-struct PreferenceInformation {
+struct PreferenceInformation
+{
   /**
    * An `enum GNUNET_ATS_PreferenceKind` in NBO.
    */
@@ -422,7 +435,8 @@ struct PreferenceInformation {
 /**
  * Client to ATS: I have a performance preference for a peer.
  */
-struct ChangePreferenceMessage {
+struct ChangePreferenceMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE.
    */
@@ -447,7 +461,8 @@ struct ChangePreferenceMessage {
 /**
  * Message containing application feedback for a peer
  */
-struct FeedbackPreferenceMessage {
+struct FeedbackPreferenceMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK.
    */
diff --git a/src/ats/ats2.h b/src/ats/ats2.h
index 723a8440d..df402dba2 100644
--- a/src/ats/ats2.h
+++ b/src/ats/ats2.h
@@ -36,7 +36,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
 /**
  * ATS performance characteristics for an address.
  */
-struct PropertiesNBO {
+struct PropertiesNBO
+{
   /**
    * Delay.  Time between when the time packet is sent and the packet
    * arrives.  FOREVER if we did not (successfully) measure yet.
@@ -106,7 +107,8 @@ struct PropertiesNBO {
  * Application client to ATS service: we would like to have
  * address suggestions for this peer.
  */
-struct ExpressPreferenceMessage {
+struct ExpressPreferenceMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_SUGGEST or
    * #GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL to stop
@@ -135,7 +137,8 @@ struct ExpressPreferenceMessage {
 /**
  * Transport client to ATS service: here is another session you can use.
  */
-struct SessionAddMessage {
+struct SessionAddMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD or
    * #GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY
@@ -168,7 +171,8 @@ struct SessionAddMessage {
  * Message used to notify ATS that the performance
  * characteristics for an session have changed.
  */
-struct SessionUpdateMessage {
+struct SessionUpdateMessage
+{
   /**
    * Message of type #GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE.
    */
@@ -198,7 +202,8 @@ struct SessionUpdateMessage {
  * was destroyed and must thus henceforth no longer be considered
  * for scheduling.
  */
-struct SessionDelMessage {
+struct SessionDelMessage
+{
   /**
    * Type is #GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL.
    */
@@ -223,7 +228,8 @@ struct SessionDelMessage {
  * identified by the given @e session_id for the given @e peer with
  * the given @e bandwidth_in and @e bandwidth_out limits from now on.
  */
-struct SessionAllocationMessage {
+struct SessionAllocationMessage
+{
   /**
    * A message of type #GNUNET_MESSAGE_TYPE_ATS_SESSION_ALLOCATION.
    */
@@ -258,7 +264,8 @@ struct SessionAllocationMessage {
  * ATS Service suggests to the transport service to try the address
  * for the given @e peer.
  */
-struct AddressSuggestionMessage {
+struct AddressSuggestionMessage
+{
   /**
    * A message of type #GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION.
    */
diff --git a/src/ats/ats_api2_application.c b/src/ats/ats_api2_application.c
index 2a21a116a..46e57c5bb 100644
--- a/src/ats/ats_api2_application.c
+++ b/src/ats/ats_api2_application.c
@@ -28,13 +28,15 @@
 #include "ats2.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-application-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-application-api", \
+                                        __VA_ARGS__)
 
 
 /**
  * Handle for ATS address suggestion requests.
  */
-struct GNUNET_ATS_ApplicationSuggestHandle {
+struct GNUNET_ATS_ApplicationSuggestHandle
+{
   /**
    * ID of the peer for which address suggestion was requested.
    */
@@ -60,7 +62,8 @@ struct GNUNET_ATS_ApplicationSuggestHandle {
 /**
  * Handle to the ATS subsystem for application management.
  */
-struct GNUNET_ATS_ApplicationHandle {
+struct GNUNET_ATS_ApplicationHandle
+{
   /**
    * Our configuration.
    */
@@ -96,7 +99,7 @@ struct GNUNET_ATS_ApplicationHandle {
  * @param ch handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_ApplicationHandle *ch);
+reconnect (struct GNUNET_ATS_ApplicationHandle *ch);
 
 
 /**
@@ -105,12 +108,12 @@ reconnect(struct GNUNET_ATS_ApplicationHandle *ch);
  * @param cls handle to use to re-connect.
  */
 static void
-reconnect_task(void *cls)
+reconnect_task (void *cls)
 {
   struct GNUNET_ATS_ApplicationHandle *ch = cls;
 
   ch->task = NULL;
-  reconnect(ch);
+  reconnect (ch);
 }
 
 
@@ -120,17 +123,17 @@ reconnect_task(void *cls)
  * @param ch our handle
  */
 static void
-force_reconnect(struct GNUNET_ATS_ApplicationHandle *ch)
+force_reconnect (struct GNUNET_ATS_ApplicationHandle *ch)
 {
   if (NULL != ch->mq)
-    {
-      GNUNET_MQ_destroy(ch->mq);
-      ch->mq = NULL;
-    }
-  ch->backoff = GNUNET_TIME_STD_BACKOFF(ch->backoff);
-  ch->task = GNUNET_SCHEDULER_add_delayed(ch->backoff,
-                                          &reconnect_task,
-                                          ch);
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
+  ch->backoff = GNUNET_TIME_STD_BACKOFF (ch->backoff);
+  ch->task = GNUNET_SCHEDULER_add_delayed (ch->backoff,
+                                           &reconnect_task,
+                                           ch);
 }
 
 
@@ -142,15 +145,15 @@ force_reconnect(struct GNUNET_ATS_ApplicationHandle *ch)
  * @param error details about the error
  */
 static void
-error_handler(void *cls,
-              enum GNUNET_MQ_Error error)
+error_handler (void *cls,
+               enum GNUNET_MQ_Error error)
 {
   struct GNUNET_ATS_ApplicationHandle *ch = cls;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "ATS connection died (code %d), reconnecting\n",
-      (int)error);
-  force_reconnect(ch);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "ATS connection died (code %d), reconnecting\n",
+       (int) error);
+  force_reconnect (ch);
 }
 
 
@@ -164,9 +167,9 @@ error_handler(void *cls,
  *         failure (message queue no longer exists)
  */
 static int
-transmit_suggestion(void *cls,
-                    const struct GNUNET_PeerIdentity *peer,
-                    void *value)
+transmit_suggestion (void *cls,
+                     const struct GNUNET_PeerIdentity *peer,
+                     void *value)
 {
   struct GNUNET_ATS_ApplicationHandle *ch = cls;
   struct GNUNET_ATS_ApplicationSuggestHandle *sh = value;
@@ -175,12 +178,12 @@ transmit_suggestion(void *cls,
 
   if (NULL == ch->mq)
     return GNUNET_SYSERR;
-  ev = GNUNET_MQ_msg(m,
-                     GNUNET_MESSAGE_TYPE_ATS_SUGGEST);
-  m->pk = htonl((uint32_t)sh->pk);
+  ev = GNUNET_MQ_msg (m,
+                      GNUNET_MESSAGE_TYPE_ATS_SUGGEST);
+  m->pk = htonl ((uint32_t) sh->pk);
   m->bw = sh->bw;
   m->peer = *peer;
-  GNUNET_MQ_send(ch->mq, ev);
+  GNUNET_MQ_send (ch->mq, ev);
   return GNUNET_OK;
 }
 
@@ -191,26 +194,26 @@ transmit_suggestion(void *cls,
  * @param ch handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_ApplicationHandle *ch)
+reconnect (struct GNUNET_ATS_ApplicationHandle *ch)
 {
   static const struct GNUNET_MQ_MessageHandler handlers[] = {
     { NULL, 0, 0 }
   };
 
-  GNUNET_assert(NULL == ch->mq);
-  ch->mq = GNUNET_CLIENT_connect(ch->cfg,
-                                 "ats",
-                                 handlers,
-                                 &error_handler,
-                                 ch);
+  GNUNET_assert (NULL == ch->mq);
+  ch->mq = GNUNET_CLIENT_connect (ch->cfg,
+                                  "ats",
+                                  handlers,
+                                  &error_handler,
+                                  ch);
   if (NULL == ch->mq)
-    {
-      force_reconnect(ch);
-      return;
-    }
-  GNUNET_CONTAINER_multipeermap_iterate(ch->sug_requests,
-                                        &transmit_suggestion,
-                                        ch);
+  {
+    force_reconnect (ch);
+    return;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &transmit_suggestion,
+                                         ch);
 }
 
 
@@ -221,15 +224,15 @@ reconnect(struct GNUNET_ATS_ApplicationHandle *ch)
  * @return ats application handle, NULL on error
  */
 struct GNUNET_ATS_ApplicationHandle *
-GNUNET_ATS_application_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_ATS_application_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_ATS_ApplicationHandle *ch;
 
-  ch = GNUNET_new(struct GNUNET_ATS_ApplicationHandle);
+  ch = GNUNET_new (struct GNUNET_ATS_ApplicationHandle);
   ch->cfg = cfg;
-  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create(32,
-                                                          GNUNET_YES);
-  reconnect(ch);
+  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create (32,
+                                                           GNUNET_YES);
+  reconnect (ch);
   return ch;
 }
 
@@ -244,13 +247,13 @@ GNUNET_ATS_application_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_sug_handle(void *cls,
-                const struct GNUNET_PeerIdentity *key,
-                void *value)
+free_sug_handle (void *cls,
+                 const struct GNUNET_PeerIdentity *key,
+                 void *value)
 {
   struct GNUNET_ATS_ApplicationSuggestHandle *cur = value;
 
-  GNUNET_free(cur);
+  GNUNET_free (cur);
   return GNUNET_OK;
 }
 
@@ -261,23 +264,23 @@ free_sug_handle(void *cls,
  * @param ch handle to release
  */
 void
-GNUNET_ATS_application_done(struct GNUNET_ATS_ApplicationHandle *ch)
+GNUNET_ATS_application_done (struct GNUNET_ATS_ApplicationHandle *ch)
 {
   if (NULL != ch->mq)
-    {
-      GNUNET_MQ_destroy(ch->mq);
-      ch->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
   if (NULL != ch->task)
-    {
-      GNUNET_SCHEDULER_cancel(ch->task);
-      ch->task = NULL;
-    }
-  GNUNET_CONTAINER_multipeermap_iterate(ch->sug_requests,
-                                        &free_sug_handle,
-                                        NULL);
-  GNUNET_CONTAINER_multipeermap_destroy(ch->sug_requests);
-  GNUNET_free(ch);
+  {
+    GNUNET_SCHEDULER_cancel (ch->task);
+    ch->task = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &free_sug_handle,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (ch->sug_requests);
+  GNUNET_free (ch);
 }
 
 
@@ -295,31 +298,31 @@ GNUNET_ATS_application_done(struct GNUNET_ATS_ApplicationHandle *ch)
  * @return suggest handle, NULL if a request is already pending
  */
 struct GNUNET_ATS_ApplicationSuggestHandle *
-GNUNET_ATS_application_suggest(struct GNUNET_ATS_ApplicationHandle *ch,
-                               const struct GNUNET_PeerIdentity *peer,
-                               enum GNUNET_MQ_PreferenceKind pk,
-                               struct GNUNET_BANDWIDTH_Value32NBO bw)
+GNUNET_ATS_application_suggest (struct GNUNET_ATS_ApplicationHandle *ch,
+                                const struct GNUNET_PeerIdentity *peer,
+                                enum GNUNET_MQ_PreferenceKind pk,
+                                struct GNUNET_BANDWIDTH_Value32NBO bw)
 {
   struct GNUNET_ATS_ApplicationSuggestHandle *s;
 
-  s = GNUNET_new(struct GNUNET_ATS_ApplicationSuggestHandle);
+  s = GNUNET_new (struct GNUNET_ATS_ApplicationSuggestHandle);
   s->ch = ch;
   s->id = *peer;
   s->pk = pk;
   s->bw = bw;
-  (void)GNUNET_CONTAINER_multipeermap_put(ch->sug_requests,
-                                          &s->id,
-                                          s,
-                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Requesting ATS to suggest address for `%s'\n",
-      GNUNET_i2s(peer));
+  (void) GNUNET_CONTAINER_multipeermap_put (ch->sug_requests,
+                                            &s->id,
+                                            s,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Requesting ATS to suggest address for `%s'\n",
+       GNUNET_i2s (peer));
   if (NULL == ch->mq)
     return s;
-  GNUNET_assert(GNUNET_OK ==
-                transmit_suggestion(ch,
-                                    &s->id,
-                                    s));
+  GNUNET_assert (GNUNET_OK ==
+                 transmit_suggestion (ch,
+                                      &s->id,
+                                      s));
   return s;
 }
 
@@ -330,32 +333,33 @@ GNUNET_ATS_application_suggest(struct GNUNET_ATS_ApplicationHandle *ch,
  * @param sh handle to stop
  */
 void
-GNUNET_ATS_application_suggest_cancel(struct GNUNET_ATS_ApplicationSuggestHandle *sh)
+GNUNET_ATS_application_suggest_cancel (struct
+                                       GNUNET_ATS_ApplicationSuggestHandle *sh)
 {
   struct GNUNET_ATS_ApplicationHandle *ch = sh->ch;
   struct GNUNET_MQ_Envelope *ev;
   struct ExpressPreferenceMessage *m;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Telling ATS we no longer care for an address for `%s'\n",
-      GNUNET_i2s(&sh->id));
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_remove(ch->sug_requests,
-                                                     &sh->id,
-                                                     sh));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Telling ATS we no longer care for an address for `%s'\n",
+       GNUNET_i2s (&sh->id));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_remove (ch->sug_requests,
+                                                       &sh->id,
+                                                       sh));
   if (NULL == ch->mq)
-    {
-      GNUNET_free(sh);
-      return;
-    }
-  ev = GNUNET_MQ_msg(m,
-                     GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL);
-  m->pk = htonl((uint32_t)sh->pk);
+  {
+    GNUNET_free (sh);
+    return;
+  }
+  ev = GNUNET_MQ_msg (m,
+                      GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL);
+  m->pk = htonl ((uint32_t) sh->pk);
   m->bw = sh->bw;
   m->peer = sh->id;
-  GNUNET_MQ_send(ch->mq,
-                 ev);
-  GNUNET_free(sh);
+  GNUNET_MQ_send (ch->mq,
+                  ev);
+  GNUNET_free (sh);
 }
 
 
diff --git a/src/ats/ats_api2_transport.c b/src/ats/ats_api2_transport.c
index 441e7c8c2..da02ca592 100644
--- a/src/ats/ats_api2_transport.c
+++ b/src/ats/ats_api2_transport.c
@@ -27,7 +27,7 @@
 #include "gnunet_ats_transport_service.h"
 #include "ats2.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-transport-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-transport-api", __VA_ARGS__)
 
 
 /**
@@ -35,7 +35,8 @@
  * doesn't matter if we have a session, any session that ATS is
  * allowed to suggest right now should be tracked.
  */
-struct GNUNET_ATS_SessionRecord {
+struct GNUNET_ATS_SessionRecord
+{
   /**
    * Transport handle this session record belongs to.
    */
@@ -79,7 +80,8 @@ struct GNUNET_ATS_SessionRecord {
 /**
  * Handle to the ATS subsystem for bandwidth/transport transport information.
  */
-struct GNUNET_ATS_TransportHandle {
+struct GNUNET_ATS_TransportHandle
+{
   /**
    * Our configuration.
    */
@@ -135,18 +137,18 @@ struct GNUNET_ATS_TransportHandle {
  * @param hbo value read
  */
 static void
-properties_hton(struct PropertiesNBO *nbo,
-                const struct GNUNET_ATS_Properties *hbo)
+properties_hton (struct PropertiesNBO *nbo,
+                 const struct GNUNET_ATS_Properties *hbo)
 {
-  nbo->delay = GNUNET_TIME_relative_hton(hbo->delay);
-  nbo->goodput_out = htonl(hbo->goodput_out);
-  nbo->goodput_in = htonl(hbo->goodput_in);
-  nbo->utilization_out = htonl(hbo->utilization_out);
-  nbo->utilization_in = htonl(hbo->utilization_in);
-  nbo->distance = htonl(hbo->distance);
-  nbo->mtu = htonl(hbo->mtu);
-  nbo->nt = htonl((uint32_t)hbo->nt);
-  nbo->cc = htonl((uint32_t)hbo->cc);
+  nbo->delay = GNUNET_TIME_relative_hton (hbo->delay);
+  nbo->goodput_out = htonl (hbo->goodput_out);
+  nbo->goodput_in = htonl (hbo->goodput_in);
+  nbo->utilization_out = htonl (hbo->utilization_out);
+  nbo->utilization_in = htonl (hbo->utilization_in);
+  nbo->distance = htonl (hbo->distance);
+  nbo->mtu = htonl (hbo->mtu);
+  nbo->nt = htonl ((uint32_t) hbo->nt);
+  nbo->cc = htonl ((uint32_t) hbo->cc);
 }
 
 
@@ -156,7 +158,7 @@ properties_hton(struct PropertiesNBO *nbo,
  * @param sh handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_TransportHandle *ath);
+reconnect (struct GNUNET_ATS_TransportHandle *ath);
 
 
 /**
@@ -165,12 +167,12 @@ reconnect(struct GNUNET_ATS_TransportHandle *ath);
  * @param cls handle to use to re-connect.
  */
 static void
-reconnect_task(void *cls)
+reconnect_task (void *cls)
 {
   struct GNUNET_ATS_TransportHandle *ath = cls;
 
   ath->task = NULL;
-  reconnect(ath);
+  reconnect (ath);
 }
 
 
@@ -180,22 +182,22 @@ reconnect_task(void *cls)
  * @param ath our handle
  */
 static void
-force_reconnect(struct GNUNET_ATS_TransportHandle *ath)
+force_reconnect (struct GNUNET_ATS_TransportHandle *ath)
 {
   if (NULL != ath->mq)
-    {
-      GNUNET_MQ_destroy(ath->mq);
-      ath->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (ath->mq);
+    ath->mq = NULL;
+  }
   /* FIXME: do we tell transport service about disconnect events? CON:
      initially ATS will have a really screwed picture of the world and
      the rapid change would be bad.  PRO: if we don't, ATS and
      transport may disagree about the allocation for a while...
      For now: lazy: do nothing. */
-  ath->backoff = GNUNET_TIME_STD_BACKOFF(ath->backoff);
-  ath->task = GNUNET_SCHEDULER_add_delayed(ath->backoff,
-                                           &reconnect_task,
-                                           ath);
+  ath->backoff = GNUNET_TIME_STD_BACKOFF (ath->backoff);
+  ath->task = GNUNET_SCHEDULER_add_delayed (ath->backoff,
+                                            &reconnect_task,
+                                            ath);
 }
 
 
@@ -206,11 +208,11 @@ force_reconnect(struct GNUNET_ATS_TransportHandle *ath)
  * @param m message received
  */
 static int
-check_ats_address_suggestion(void *cls,
-                             const struct AddressSuggestionMessage *m)
+check_ats_address_suggestion (void *cls,
+                              const struct AddressSuggestionMessage *m)
 {
-  (void)cls;
-  GNUNET_MQ_check_zero_termination(m);
+  (void) cls;
+  GNUNET_MQ_check_zero_termination (m);
   return GNUNET_SYSERR;
 }
 
@@ -222,22 +224,23 @@ check_ats_address_suggestion(void *cls,
  * @param m message received
  */
 static void
-handle_ats_address_suggestion(void *cls,
-                              const struct AddressSuggestionMessage *m)
+handle_ats_address_suggestion (void *cls,
+                               const struct AddressSuggestionMessage *m)
 {
   struct GNUNET_ATS_TransportHandle *ath = cls;
-  const char *address = (const char *)&m[1];
+  const char *address = (const char *) &m[1];
 
-  ath->suggest_cb(ath->suggest_cb_cls,
-                  &m->peer,
-                  address);
+  ath->suggest_cb (ath->suggest_cb_cls,
+                   &m->peer,
+                   address);
 }
 
 
 /**
  * Closure for #match_session_cb.
  */
-struct FindContext {
+struct FindContext
+{
   /**
    * Key to look for.
    */
@@ -259,19 +262,19 @@ struct FindContext {
  * @return #GNUNET_NO if match found, #GNUNET_YES to continue searching
  */
 static int
-match_session_cb(void *cls,
-                 const struct GNUNET_PeerIdentity *pid,
-                 void *value)
+match_session_cb (void *cls,
+                  const struct GNUNET_PeerIdentity *pid,
+                  void *value)
 {
   struct FindContext *fc = cls;
   struct GNUNET_ATS_SessionRecord *sr = value;
 
-  (void)pid;
+  (void) pid;
   if (fc->session_id == sr->slot)
-    {
-      fc->sr = sr;
-      return GNUNET_NO;
-    }
+  {
+    fc->sr = sr;
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -286,19 +289,19 @@ match_session_cb(void *cls,
  * @return NULL if no such record exists
  */
 static struct GNUNET_ATS_SessionRecord *
-find_session(struct GNUNET_ATS_TransportHandle *ath,
-             uint32_t session_id,
-             const struct GNUNET_PeerIdentity *pid)
+find_session (struct GNUNET_ATS_TransportHandle *ath,
+              uint32_t session_id,
+              const struct GNUNET_PeerIdentity *pid)
 {
   struct FindContext fc = {
     .session_id = session_id,
     .sr = NULL
   };
 
-  GNUNET_CONTAINER_multipeermap_get_multiple(ath->records,
-                                             pid,
-                                             &match_session_cb,
-                                             &fc);
+  GNUNET_CONTAINER_multipeermap_get_multiple (ath->records,
+                                              pid,
+                                              &match_session_cb,
+                                              &fc);
   return fc.sr;
 }
 
@@ -310,34 +313,34 @@ find_session(struct GNUNET_ATS_TransportHandle *ath,
  * @param m message received
  */
 static void
-handle_ats_session_allocation(void *cls,
-                              const struct SessionAllocationMessage *m)
+handle_ats_session_allocation (void *cls,
+                               const struct SessionAllocationMessage *m)
 {
   struct GNUNET_ATS_TransportHandle *ath = cls;
   struct GNUNET_ATS_SessionRecord *ar;
   uint32_t session_id;
 
-  session_id = ntohl(m->session_id);
-  ar = find_session(ath,
-                    session_id,
-                    &m->peer);
+  session_id = ntohl (m->session_id);
+  ar = find_session (ath,
+                     session_id,
+                     &m->peer);
   if (NULL == ar)
-    {
-      /* this can (rarely) happen if ATS changes an sessiones allocation
-         just when the transport service deleted it */
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Allocation ignored, session unknown\n");
-      return;
-    }
+  {
+    /* this can (rarely) happen if ATS changes an sessiones allocation
+       just when the transport service deleted it */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Allocation ignored, session unknown\n");
+    return;
+  }
   ath->backoff = GNUNET_TIME_UNIT_ZERO;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "ATS allocates bandwidth for peer `%s' using address %s\n",
-      GNUNET_i2s(&ar->pid),
-      ar->address);
-  ath->alloc_cb(ath->alloc_cb_cls,
-                ar->session,
-                m->bandwidth_out,
-                m->bandwidth_in);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "ATS allocates bandwidth for peer `%s' using address %s\n",
+       GNUNET_i2s (&ar->pid),
+       ar->address);
+  ath->alloc_cb (ath->alloc_cb_cls,
+                 ar->session,
+                 m->bandwidth_out,
+                 m->bandwidth_in);
 }
 
 
@@ -349,15 +352,15 @@ handle_ats_session_allocation(void *cls,
  * @param error details about the error
  */
 static void
-error_handler(void *cls,
-              enum GNUNET_MQ_Error error)
+error_handler (void *cls,
+               enum GNUNET_MQ_Error error)
 {
   struct GNUNET_ATS_TransportHandle *ath = cls;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "ATS connection died (code %d), reconnecting\n",
-      (int)error);
-  force_reconnect(ath);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "ATS connection died (code %d), reconnecting\n",
+       (int) error);
+  force_reconnect (ath);
 }
 
 
@@ -368,7 +371,7 @@ error_handler(void *cls,
  * @param ar the session to inform the ATS service about
  */
 static void
-send_add_session_message(const struct GNUNET_ATS_SessionRecord *ar)
+send_add_session_message (const struct GNUNET_ATS_SessionRecord *ar)
 {
   struct GNUNET_ATS_TransportHandle *ath = ar->ath;
   struct GNUNET_MQ_Envelope *ev;
@@ -377,26 +380,26 @@ send_add_session_message(const struct GNUNET_ATS_SessionRecord *ar)
 
   if (NULL == ath->mq)
     return; /* disconnected, skip for now */
-  alen = strlen(ar->address) + 1;
-  ev = GNUNET_MQ_msg_extra(m,
-                           alen,
-                           (NULL == ar->session)
-                           ? GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY
-                           : GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD);
+  alen = strlen (ar->address) + 1;
+  ev = GNUNET_MQ_msg_extra (m,
+                            alen,
+                            (NULL == ar->session)
+                            ? GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY
+                            : GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD);
   m->peer = ar->pid;
-  m->session_id = htonl(ar->slot);
-  properties_hton(&m->properties,
-                  &ar->properties);
-  GNUNET_memcpy(&m[1],
-                ar->address,
-                alen);
-
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Adding address `%s' for peer `%s'\n",
-      ar->address,
-      GNUNET_i2s(&ar->pid));
-  GNUNET_MQ_send(ath->mq,
-                 ev);
+  m->session_id = htonl (ar->slot);
+  properties_hton (&m->properties,
+                   &ar->properties);
+  GNUNET_memcpy (&m[1],
+                 ar->address,
+                 alen);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding address `%s' for peer `%s'\n",
+       ar->address,
+       GNUNET_i2s (&ar->pid));
+  GNUNET_MQ_send (ath->mq,
+                  ev);
 }
 
 
@@ -409,15 +412,15 @@ send_add_session_message(const struct GNUNET_ATS_SessionRecord *ar)
  * @return #GNUNET_OK
  */
 static int
-send_add_session_cb(void *cls,
-                    const struct GNUNET_PeerIdentity *pid,
-                    void *value)
+send_add_session_cb (void *cls,
+                     const struct GNUNET_PeerIdentity *pid,
+                     void *value)
 {
   struct GNUNET_ATS_SessionRecord *ar = value;
 
-  (void)cls;
-  (void)pid;
-  send_add_session_message(ar);
+  (void) cls;
+  (void) pid;
+  send_add_session_message (ar);
   return GNUNET_OK;
 }
 
@@ -428,43 +431,43 @@ send_add_session_cb(void *cls,
  * @param ath handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_TransportHandle *ath)
+reconnect (struct GNUNET_ATS_TransportHandle *ath)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size(ats_address_suggestion,
-                          GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION,
-                          struct AddressSuggestionMessage,
-                          ath),
-    GNUNET_MQ_hd_fixed_size(ats_session_allocation,
-                            GNUNET_MESSAGE_TYPE_ATS_SESSION_ALLOCATION,
-                            struct SessionAllocationMessage,
-                            ath),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (ats_address_suggestion,
+                           GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION,
+                           struct AddressSuggestionMessage,
+                           ath),
+    GNUNET_MQ_hd_fixed_size (ats_session_allocation,
+                             GNUNET_MESSAGE_TYPE_ATS_SESSION_ALLOCATION,
+                             struct SessionAllocationMessage,
+                             ath),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_Envelope *ev;
   struct GNUNET_MessageHeader *init;
 
-  GNUNET_assert(NULL == ath->mq);
-  ath->mq = GNUNET_CLIENT_connect(ath->cfg,
-                                  "ats",
-                                  handlers,
-                                  &error_handler,
-                                  ath);
+  GNUNET_assert (NULL == ath->mq);
+  ath->mq = GNUNET_CLIENT_connect (ath->cfg,
+                                   "ats",
+                                   handlers,
+                                   &error_handler,
+                                   ath);
   if (NULL == ath->mq)
-    {
-      GNUNET_break(0);
-      force_reconnect(ath);
-      return;
-    }
-  ev = GNUNET_MQ_msg(init,
-                     GNUNET_MESSAGE_TYPE_ATS_START);
-  GNUNET_MQ_send(ath->mq,
-                 ev);
+  {
+    GNUNET_break (0);
+    force_reconnect (ath);
+    return;
+  }
+  ev = GNUNET_MQ_msg (init,
+                      GNUNET_MESSAGE_TYPE_ATS_START);
+  GNUNET_MQ_send (ath->mq,
+                  ev);
   if (NULL == ath->mq)
     return;
-  GNUNET_CONTAINER_multipeermap_iterate(ath->records,
-                                        &send_add_session_cb,
-                                        ath);
+  GNUNET_CONTAINER_multipeermap_iterate (ath->records,
+                                         &send_add_session_cb,
+                                         ath);
 }
 
 
@@ -479,23 +482,23 @@ reconnect(struct GNUNET_ATS_TransportHandle *ath)
  * @return ats context
  */
 struct GNUNET_ATS_TransportHandle *
-GNUNET_ATS_transport_init(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                          GNUNET_ATS_AllocationCallback alloc_cb,
-                          void *alloc_cb_cls,
-                          GNUNET_ATS_SuggestionCallback suggest_cb,
-                          void *suggest_cb_cls)
+GNUNET_ATS_transport_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                           GNUNET_ATS_AllocationCallback alloc_cb,
+                           void *alloc_cb_cls,
+                           GNUNET_ATS_SuggestionCallback suggest_cb,
+                           void *suggest_cb_cls)
 {
   struct GNUNET_ATS_TransportHandle *ath;
 
-  ath = GNUNET_new(struct GNUNET_ATS_TransportHandle);
+  ath = GNUNET_new (struct GNUNET_ATS_TransportHandle);
   ath->cfg = cfg;
   ath->suggest_cb = suggest_cb;
   ath->suggest_cb_cls = suggest_cb_cls;
   ath->alloc_cb = alloc_cb;
   ath->alloc_cb_cls = alloc_cb_cls;
-  ath->records = GNUNET_CONTAINER_multipeermap_create(128,
-                                                      GNUNET_YES);
-  reconnect(ath);
+  ath->records = GNUNET_CONTAINER_multipeermap_create (128,
+                                                       GNUNET_YES);
+  reconnect (ath);
   return ath;
 }
 
@@ -509,15 +512,15 @@ GNUNET_ATS_transport_init(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return #GNUNET_OK
  */
 static int
-free_record(void *cls,
-            const struct GNUNET_PeerIdentity *pid,
-            void *value)
+free_record (void *cls,
+             const struct GNUNET_PeerIdentity *pid,
+             void *value)
 {
   struct GNUNET_ATS_SessionRecord *ar = value;
 
-  (void)cls;
-  (void)pid;
-  GNUNET_free(ar);
+  (void) cls;
+  (void) pid;
+  GNUNET_free (ar);
   return GNUNET_OK;
 }
 
@@ -528,23 +531,23 @@ free_record(void *cls,
  * @param ath handle to release
  */
 void
-GNUNET_ATS_transport_done(struct GNUNET_ATS_TransportHandle *ath)
+GNUNET_ATS_transport_done (struct GNUNET_ATS_TransportHandle *ath)
 {
   if (NULL != ath->mq)
-    {
-      GNUNET_MQ_destroy(ath->mq);
-      ath->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (ath->mq);
+    ath->mq = NULL;
+  }
   if (NULL != ath->task)
-    {
-      GNUNET_SCHEDULER_cancel(ath->task);
-      ath->task = NULL;
-    }
-  GNUNET_CONTAINER_multipeermap_iterate(ath->records,
-                                        &free_record,
-                                        NULL);
-  GNUNET_CONTAINER_multipeermap_destroy(ath->records);
-  GNUNET_free(ath);
+  {
+    GNUNET_SCHEDULER_cancel (ath->task);
+    ath->task = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ath->records,
+                                         &free_record,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (ath->records);
+  GNUNET_free (ath);
 }
 
 
@@ -563,56 +566,56 @@ GNUNET_ATS_transport_done(struct GNUNET_ATS_TransportHandle *ath)
  *         on error (i.e. ATS knows this exact session already)
  */
 struct GNUNET_ATS_SessionRecord *
-GNUNET_ATS_session_add(struct GNUNET_ATS_TransportHandle *ath,
-                       const struct GNUNET_PeerIdentity *pid,
-                       const char *address,
-                       struct GNUNET_ATS_Session *session,
-                       const struct GNUNET_ATS_Properties *prop)
+GNUNET_ATS_session_add (struct GNUNET_ATS_TransportHandle *ath,
+                        const struct GNUNET_PeerIdentity *pid,
+                        const char *address,
+                        struct GNUNET_ATS_Session *session,
+                        const struct GNUNET_ATS_Properties *prop)
 {
   struct GNUNET_ATS_SessionRecord *ar;
   uint32_t s;
   size_t alen;
 
   if (NULL == address)
-    {
-      /* we need a valid address */
-      GNUNET_break(0);
-      return NULL;
-    }
-  alen = strlen(address) + 1;
+  {
+    /* we need a valid address */
+    GNUNET_break (0);
+    return NULL;
+  }
+  alen = strlen (address) + 1;
   if ((alen + sizeof(struct SessionAddMessage) >= GNUNET_MAX_MESSAGE_SIZE) ||
       (alen >= GNUNET_MAX_MESSAGE_SIZE))
-    {
-      /* address too large for us, this should not happen */
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    /* address too large for us, this should not happen */
+    GNUNET_break (0);
+    return NULL;
+  }
 
   /* Spin 's' until we find an unused session ID for this pid */
-  for (s = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                    UINT32_MAX);
-       NULL != find_session(ath,
-                            s,
-                            pid);
+  for (s = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                     UINT32_MAX);
+       NULL != find_session (ath,
+                             s,
+                             pid);
        s++)
     ;
 
-  alen = strlen(address) + 1;
-  ar = GNUNET_malloc(sizeof(struct GNUNET_ATS_SessionRecord) + alen);
+  alen = strlen (address) + 1;
+  ar = GNUNET_malloc (sizeof(struct GNUNET_ATS_SessionRecord) + alen);
   ar->ath = ath;
   ar->slot = s;
   ar->session = session;
-  ar->address = (const char *)&ar[1];
+  ar->address = (const char *) &ar[1];
   ar->pid = *pid;
   ar->properties = *prop;
-  memcpy(&ar[1],
-         address,
-         alen);
-  (void)GNUNET_CONTAINER_multipeermap_put(ath->records,
-                                          &ar->pid,
-                                          ar,
-                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  send_add_session_message(ar);
+  memcpy (&ar[1],
+          address,
+          alen);
+  (void) GNUNET_CONTAINER_multipeermap_put (ath->records,
+                                            &ar->pid,
+                                            ar,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  send_add_session_message (ar);
   return ar;
 }
 
@@ -629,28 +632,28 @@ GNUNET_ATS_session_add(struct GNUNET_ATS_TransportHandle *ath,
  * @param prop performance data for the session
  */
 void
-GNUNET_ATS_session_update(struct GNUNET_ATS_SessionRecord *ar,
-                          const struct GNUNET_ATS_Properties *prop)
+GNUNET_ATS_session_update (struct GNUNET_ATS_SessionRecord *ar,
+                           const struct GNUNET_ATS_Properties *prop)
 {
   struct GNUNET_ATS_TransportHandle *ath = ar->ath;
   struct GNUNET_MQ_Envelope *ev;
   struct SessionUpdateMessage *m;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Updating address `%s' for peer `%s'\n",
-      ar->address,
-      GNUNET_i2s(&ar->pid));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Updating address `%s' for peer `%s'\n",
+       ar->address,
+       GNUNET_i2s (&ar->pid));
   ar->properties = *prop;
   if (NULL == ath->mq)
     return; /* disconnected, skip for now */
-  ev = GNUNET_MQ_msg(m,
-                     GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE);
-  m->session_id = htonl(ar->slot);
+  ev = GNUNET_MQ_msg (m,
+                      GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE);
+  m->session_id = htonl (ar->slot);
   m->peer = ar->pid;
-  properties_hton(&m->properties,
-                  &ar->properties);
-  GNUNET_MQ_send(ath->mq,
-                 ev);
+  properties_hton (&m->properties,
+                   &ar->properties);
+  GNUNET_MQ_send (ath->mq,
+                  ev);
 }
 
 
@@ -662,24 +665,24 @@ GNUNET_ATS_session_update(struct GNUNET_ATS_SessionRecord *ar,
  * @param ar session record to drop
  */
 void
-GNUNET_ATS_session_del(struct GNUNET_ATS_SessionRecord *ar)
+GNUNET_ATS_session_del (struct GNUNET_ATS_SessionRecord *ar)
 {
   struct GNUNET_ATS_TransportHandle *ath = ar->ath;
   struct GNUNET_MQ_Envelope *ev;
   struct SessionDelMessage *m;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Deleting address `%s' for peer `%s'\n",
-      ar->address,
-      GNUNET_i2s(&ar->pid));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Deleting address `%s' for peer `%s'\n",
+       ar->address,
+       GNUNET_i2s (&ar->pid));
   if (NULL == ath->mq)
     return;
-  ev = GNUNET_MQ_msg(m,
-                     GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL);
-  m->session_id = htonl(ar->slot);
+  ev = GNUNET_MQ_msg (m,
+                      GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL);
+  m->session_id = htonl (ar->slot);
   m->peer = ar->pid;
-  GNUNET_MQ_send(ath->mq,
-                 ev);
+  GNUNET_MQ_send (ath->mq,
+                  ev);
 }
 
 
diff --git a/src/ats/ats_api_connectivity.c b/src/ats/ats_api_connectivity.c
index 2ff734c25..1b8e82777 100644
--- a/src/ats/ats_api_connectivity.c
+++ b/src/ats/ats_api_connectivity.c
@@ -28,13 +28,15 @@
 #include "ats.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-connectivity-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-connectivity-api", \
+                                        __VA_ARGS__)
 
 
 /**
  * Handle for ATS address suggestion requests.
  */
-struct GNUNET_ATS_ConnectivitySuggestHandle {
+struct GNUNET_ATS_ConnectivitySuggestHandle
+{
   /**
    * ID of the peer for which address suggestion was requested.
    */
@@ -55,7 +57,8 @@ struct GNUNET_ATS_ConnectivitySuggestHandle {
 /**
  * Handle to the ATS subsystem for connectivity management.
  */
-struct GNUNET_ATS_ConnectivityHandle {
+struct GNUNET_ATS_ConnectivityHandle
+{
   /**
    * Our configuration.
    */
@@ -91,7 +94,7 @@ struct GNUNET_ATS_ConnectivityHandle {
  * @param ch handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_ConnectivityHandle *ch);
+reconnect (struct GNUNET_ATS_ConnectivityHandle *ch);
 
 
 /**
@@ -100,12 +103,12 @@ reconnect(struct GNUNET_ATS_ConnectivityHandle *ch);
  * @param cls handle to use to re-connect.
  */
 static void
-reconnect_task(void *cls)
+reconnect_task (void *cls)
 {
   struct GNUNET_ATS_ConnectivityHandle *ch = cls;
 
   ch->task = NULL;
-  reconnect(ch);
+  reconnect (ch);
 }
 
 
@@ -115,17 +118,17 @@ reconnect_task(void *cls)
  * @param ch our handle
  */
 static void
-force_reconnect(struct GNUNET_ATS_ConnectivityHandle *ch)
+force_reconnect (struct GNUNET_ATS_ConnectivityHandle *ch)
 {
   if (NULL != ch->mq)
-    {
-      GNUNET_MQ_destroy(ch->mq);
-      ch->mq = NULL;
-    }
-  ch->backoff = GNUNET_TIME_STD_BACKOFF(ch->backoff);
-  ch->task = GNUNET_SCHEDULER_add_delayed(ch->backoff,
-                                          &reconnect_task,
-                                          ch);
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
+  ch->backoff = GNUNET_TIME_STD_BACKOFF (ch->backoff);
+  ch->task = GNUNET_SCHEDULER_add_delayed (ch->backoff,
+                                           &reconnect_task,
+                                           ch);
 }
 
 
@@ -137,15 +140,15 @@ force_reconnect(struct GNUNET_ATS_ConnectivityHandle *ch)
  * @param error details about the error
  */
 static void
-error_handler(void *cls,
-              enum GNUNET_MQ_Error error)
+error_handler (void *cls,
+               enum GNUNET_MQ_Error error)
 {
   struct GNUNET_ATS_ConnectivityHandle *ch = cls;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "ATS connection died (code %d), reconnecting\n",
-      (int)error);
-  force_reconnect(ch);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "ATS connection died (code %d), reconnecting\n",
+       (int) error);
+  force_reconnect (ch);
 }
 
 
@@ -159,9 +162,9 @@ error_handler(void *cls,
  *         failure (message queue no longer exists)
  */
 static int
-transmit_suggestion(void *cls,
-                    const struct GNUNET_PeerIdentity *peer,
-                    void *value)
+transmit_suggestion (void *cls,
+                     const struct GNUNET_PeerIdentity *peer,
+                     void *value)
 {
   struct GNUNET_ATS_ConnectivityHandle *ch = cls;
   struct GNUNET_ATS_ConnectivitySuggestHandle *sh = value;
@@ -170,10 +173,10 @@ transmit_suggestion(void *cls,
 
   if (NULL == ch->mq)
     return GNUNET_SYSERR;
-  ev = GNUNET_MQ_msg(m, GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS);
-  m->strength = htonl(sh->strength);
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS);
+  m->strength = htonl (sh->strength);
   m->peer = *peer;
-  GNUNET_MQ_send(ch->mq, ev);
+  GNUNET_MQ_send (ch->mq, ev);
   return GNUNET_OK;
 }
 
@@ -184,33 +187,33 @@ transmit_suggestion(void *cls,
  * @param ch handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_ConnectivityHandle *ch)
+reconnect (struct GNUNET_ATS_ConnectivityHandle *ch)
 {
   static const struct GNUNET_MQ_MessageHandler handlers[] =
   { { NULL, 0, 0 } };
   struct GNUNET_MQ_Envelope *ev;
   struct ClientStartMessage *init;
 
-  GNUNET_assert(NULL == ch->mq);
-  ch->mq = GNUNET_CLIENT_connect(ch->cfg,
-                                 "ats",
-                                 handlers,
-                                 &error_handler,
-                                 ch);
+  GNUNET_assert (NULL == ch->mq);
+  ch->mq = GNUNET_CLIENT_connect (ch->cfg,
+                                  "ats",
+                                  handlers,
+                                  &error_handler,
+                                  ch);
   if (NULL == ch->mq)
-    {
-      force_reconnect(ch);
-      return;
-    }
-  ev = GNUNET_MQ_msg(init,
-                     GNUNET_MESSAGE_TYPE_ATS_START);
-  init->start_flag = htonl(START_FLAG_CONNECTION_SUGGESTION);
-  GNUNET_MQ_send(ch->mq, ev);
+  {
+    force_reconnect (ch);
+    return;
+  }
+  ev = GNUNET_MQ_msg (init,
+                      GNUNET_MESSAGE_TYPE_ATS_START);
+  init->start_flag = htonl (START_FLAG_CONNECTION_SUGGESTION);
+  GNUNET_MQ_send (ch->mq, ev);
   if (NULL == ch->mq)
     return;
-  GNUNET_CONTAINER_multipeermap_iterate(ch->sug_requests,
-                                        &transmit_suggestion,
-                                        ch);
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &transmit_suggestion,
+                                         ch);
 }
 
 
@@ -221,15 +224,15 @@ reconnect(struct GNUNET_ATS_ConnectivityHandle *ch)
  * @return ats connectivity handle, NULL on error
  */
 struct GNUNET_ATS_ConnectivityHandle *
-GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_ATS_connectivity_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_ATS_ConnectivityHandle *ch;
 
-  ch = GNUNET_new(struct GNUNET_ATS_ConnectivityHandle);
+  ch = GNUNET_new (struct GNUNET_ATS_ConnectivityHandle);
   ch->cfg = cfg;
-  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create(32,
-                                                          GNUNET_YES);
-  reconnect(ch);
+  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create (32,
+                                                           GNUNET_YES);
+  reconnect (ch);
   return ch;
 }
 
@@ -244,13 +247,13 @@ GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_sug_handle(void *cls,
-                const struct GNUNET_PeerIdentity *key,
-                void *value)
+free_sug_handle (void *cls,
+                 const struct GNUNET_PeerIdentity *key,
+                 void *value)
 {
   struct GNUNET_ATS_ConnectivitySuggestHandle *cur = value;
 
-  GNUNET_free(cur);
+  GNUNET_free (cur);
   return GNUNET_OK;
 }
 
@@ -261,23 +264,23 @@ free_sug_handle(void *cls,
  * @param ch handle to release
  */
 void
-GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
+GNUNET_ATS_connectivity_done (struct GNUNET_ATS_ConnectivityHandle *ch)
 {
   if (NULL != ch->mq)
-    {
-      GNUNET_MQ_destroy(ch->mq);
-      ch->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
   if (NULL != ch->task)
-    {
-      GNUNET_SCHEDULER_cancel(ch->task);
-      ch->task = NULL;
-    }
-  GNUNET_CONTAINER_multipeermap_iterate(ch->sug_requests,
-                                        &free_sug_handle,
-                                        NULL);
-  GNUNET_CONTAINER_multipeermap_destroy(ch->sug_requests);
-  GNUNET_free(ch);
+  {
+    GNUNET_SCHEDULER_cancel (ch->task);
+    ch->task = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &free_sug_handle,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (ch->sug_requests);
+  GNUNET_free (ch);
 }
 
 
@@ -293,36 +296,36 @@ GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
  * @return suggest handle, NULL if a request is already pending
  */
 struct GNUNET_ATS_ConnectivitySuggestHandle *
-GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch,
-                                const struct GNUNET_PeerIdentity *peer,
-                                uint32_t strength)
+GNUNET_ATS_connectivity_suggest (struct GNUNET_ATS_ConnectivityHandle *ch,
+                                 const struct GNUNET_PeerIdentity *peer,
+                                 uint32_t strength)
 {
   struct GNUNET_ATS_ConnectivitySuggestHandle *s;
 
-  s = GNUNET_new(struct GNUNET_ATS_ConnectivitySuggestHandle);
+  s = GNUNET_new (struct GNUNET_ATS_ConnectivitySuggestHandle);
   s->ch = ch;
   s->id = *peer;
   s->strength = strength;
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_multipeermap_put(ch->sug_requests,
-                                        &s->id,
-                                        s,
-                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Not requesting ATS to suggest address for `%s', request already pending\n",
-          GNUNET_i2s(peer));
-      GNUNET_free(s);
-      return NULL;
-    }
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Requesting ATS to suggest address for `%s'\n",
-      GNUNET_i2s(peer));
+      GNUNET_CONTAINER_multipeermap_put (ch->sug_requests,
+                                         &s->id,
+                                         s,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Not requesting ATS to suggest address for `%s', request already pending\n",
+         GNUNET_i2s (peer));
+    GNUNET_free (s);
+    return NULL;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Requesting ATS to suggest address for `%s'\n",
+       GNUNET_i2s (peer));
   if (NULL == ch->mq)
     return s;
-  (void)transmit_suggestion(ch,
-                            &s->id,
-                            s);
+  (void) transmit_suggestion (ch,
+                              &s->id,
+                              s);
   return s;
 }
 
@@ -333,30 +336,31 @@ GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch,
  * @param sh handle to stop
  */
 void
-GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
+GNUNET_ATS_connectivity_suggest_cancel (struct
+                                        GNUNET_ATS_ConnectivitySuggestHandle *sh)
 {
   struct GNUNET_ATS_ConnectivityHandle *ch = sh->ch;
   struct GNUNET_MQ_Envelope *ev;
   struct RequestAddressMessage *m;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Telling ATS we no longer care for an address for `%s'\n",
-      GNUNET_i2s(&sh->id));
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_remove(ch->sug_requests,
-                                                     &sh->id,
-                                                     sh));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Telling ATS we no longer care for an address for `%s'\n",
+       GNUNET_i2s (&sh->id));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_remove (ch->sug_requests,
+                                                       &sh->id,
+                                                       sh));
   if (NULL == ch->mq)
-    {
-      GNUNET_free(sh);
-      return;
-    }
-  ev = GNUNET_MQ_msg(m,
-                     GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL);
-  m->strength = htonl(0);
+  {
+    GNUNET_free (sh);
+    return;
+  }
+  ev = GNUNET_MQ_msg (m,
+                      GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL);
+  m->strength = htonl (0);
   m->peer = sh->id;
-  GNUNET_MQ_send(ch->mq, ev);
-  GNUNET_free(sh);
+  GNUNET_MQ_send (ch->mq, ev);
+  GNUNET_free (sh);
 }
 
 
diff --git a/src/ats/ats_api_performance.c b/src/ats/ats_api_performance.c
index b30093f4c..8defd6022 100644
--- a/src/ats/ats_api_performance.c
+++ b/src/ats/ats_api_performance.c
@@ -28,13 +28,15 @@
 #include "ats.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-performance-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-performance-api", \
+                                        __VA_ARGS__)
 
 
 /**
  * Linked list of pending reservations.
  */
-struct GNUNET_ATS_ReservationContext {
+struct GNUNET_ATS_ReservationContext
+{
   /**
    * Kept in a DLL.
    */
@@ -80,7 +82,8 @@ struct GNUNET_ATS_ReservationContext {
 /**
  * Linked list of pending reservations.
  */
-struct GNUNET_ATS_AddressListHandle {
+struct GNUNET_ATS_AddressListHandle
+{
   /**
    * Kept in a DLL.
    */
@@ -131,7 +134,8 @@ struct GNUNET_ATS_AddressListHandle {
 /**
  * ATS Handle to obtain and/or modify performance information.
  */
-struct GNUNET_ATS_PerformanceHandle {
+struct GNUNET_ATS_PerformanceHandle
+{
   /**
    * Our configuration.
    */
@@ -209,7 +213,7 @@ struct GNUNET_ATS_PerformanceHandle {
  * @param ph handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_PerformanceHandle *ph);
+reconnect (struct GNUNET_ATS_PerformanceHandle *ph);
 
 
 /**
@@ -218,12 +222,12 @@ reconnect(struct GNUNET_ATS_PerformanceHandle *ph);
  * @param cls handle to use to re-connect.
  */
 static void
-reconnect_task(void *cls)
+reconnect_task (void *cls)
 {
   struct GNUNET_ATS_PerformanceHandle *ph = cls;
 
   ph->task = NULL;
-  reconnect(ph);
+  reconnect (ph);
 }
 
 
@@ -233,58 +237,58 @@ reconnect_task(void *cls)
  * @param ph handle to reconnect
  */
 static void
-do_reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
+do_reconnect (struct GNUNET_ATS_PerformanceHandle *ph)
 {
   struct GNUNET_ATS_ReservationContext *rc;
   struct GNUNET_ATS_AddressListHandle *alh;
   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_zero;
 
   if (NULL != ph->mq)
-    {
-      GNUNET_MQ_destroy(ph->mq);
-      ph->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (ph->mq);
+    ph->mq = NULL;
+  }
   while (NULL != (rc = ph->reservation_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(ph->reservation_head,
-                                  ph->reservation_tail,
-                                  rc);
-      if (NULL != rc->rcb)
-        rc->rcb(rc->rcb_cls,
-                NULL,
-                0,
-                GNUNET_TIME_UNIT_FOREVER_REL);
-      GNUNET_free(rc);
-    }
-  bandwidth_zero.value__ = htonl(0);
+  {
+    GNUNET_CONTAINER_DLL_remove (ph->reservation_head,
+                                 ph->reservation_tail,
+                                 rc);
+    if (NULL != rc->rcb)
+      rc->rcb (rc->rcb_cls,
+               NULL,
+               0,
+               GNUNET_TIME_UNIT_FOREVER_REL);
+    GNUNET_free (rc);
+  }
+  bandwidth_zero.value__ = htonl (0);
   while (NULL != (alh = ph->addresslist_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(ph->addresslist_head,
-                                  ph->addresslist_tail,
-                                  alh);
-      if (NULL != alh->cb)
-        alh->cb(alh->cb_cls,
-                NULL,
-                GNUNET_NO,
-                bandwidth_zero,
-                bandwidth_zero,
-                NULL);
-      GNUNET_free(alh);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (ph->addresslist_head,
+                                 ph->addresslist_tail,
+                                 alh);
+    if (NULL != alh->cb)
+      alh->cb (alh->cb_cls,
+               NULL,
+               GNUNET_NO,
+               bandwidth_zero,
+               bandwidth_zero,
+               NULL);
+    GNUNET_free (alh);
+  }
   if (NULL != ph->addr_info_cb)
-    {
-      /* Indicate reconnect */
-      ph->addr_info_cb(ph->addr_info_cb_cls,
-                       NULL,
-                       GNUNET_NO,
-                       bandwidth_zero,
-                       bandwidth_zero,
-                       NULL);
-    }
-  ph->backoff = GNUNET_TIME_STD_BACKOFF(ph->backoff);
-  ph->task = GNUNET_SCHEDULER_add_delayed(ph->backoff,
-                                          &reconnect_task,
-                                          ph);
+  {
+    /* Indicate reconnect */
+    ph->addr_info_cb (ph->addr_info_cb_cls,
+                      NULL,
+                      GNUNET_NO,
+                      bandwidth_zero,
+                      bandwidth_zero,
+                      NULL);
+  }
+  ph->backoff = GNUNET_TIME_STD_BACKOFF (ph->backoff);
+  ph->task = GNUNET_SCHEDULER_add_delayed (ph->backoff,
+                                           &reconnect_task,
+                                           ph);
 }
 
 
@@ -296,25 +300,25 @@ do_reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
  * @return #GNUNET_OK if the message was well-formed
  */
 static int
-check_peer_information(void *cls,
-                       const struct PeerInformationMessage *pi)
+check_peer_information (void *cls,
+                        const struct PeerInformationMessage *pi)
 {
   const char *plugin_address;
   const char *plugin_name;
   uint16_t plugin_address_length;
   uint16_t plugin_name_length;
 
-  plugin_address_length = ntohs(pi->address_length);
-  plugin_name_length = ntohs(pi->plugin_name_length);
-  plugin_address = (const char *)&pi[1];
+  plugin_address_length = ntohs (pi->address_length);
+  plugin_name_length = ntohs (pi->plugin_name_length);
+  plugin_address = (const char *) &pi[1];
   plugin_name = &plugin_address[plugin_address_length];
   if ((plugin_address_length + plugin_name_length
-       + sizeof(struct PeerInformationMessage) != ntohs(pi->header.size)) ||
+       + sizeof(struct PeerInformationMessage) != ntohs (pi->header.size)) ||
       (plugin_name[plugin_name_length - 1] != '\0'))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -327,8 +331,8 @@ check_peer_information(void *cls,
  * @return #GNUNET_OK if the message was well-formed
  */
 static void
-handle_peer_information(void *cls,
-                        const struct PeerInformationMessage *pi)
+handle_peer_information (void *cls,
+                         const struct PeerInformationMessage *pi)
 {
   struct GNUNET_ATS_PerformanceHandle *ph = cls;
   const char *plugin_address;
@@ -340,24 +344,25 @@ handle_peer_information(void *cls,
 
   if (NULL == ph->addr_info_cb)
     return;
-  plugin_address_length = ntohs(pi->address_length);
-  addr_active = (int)ntohl(pi->address_active);
-  plugin_address = (const char *)&pi[1];
+  plugin_address_length = ntohs (pi->address_length);
+  addr_active = (int) ntohl (pi->address_active);
+  plugin_address = (const char *) &pi[1];
   plugin_name = &plugin_address[plugin_address_length];
 
-  GNUNET_ATS_properties_ntoh(&prop,
-                             &pi->properties);
+  GNUNET_ATS_properties_ntoh (&prop,
+                              &pi->properties);
   address.peer = pi->peer;
-  address.local_info = (enum GNUNET_HELLO_AddressInfo)ntohl(pi->address_local_info);
+  address.local_info = (enum GNUNET_HELLO_AddressInfo) ntohl (
+    pi->address_local_info);
   address.address = plugin_address;
   address.address_length = plugin_address_length;
   address.transport_name = plugin_name;
-  ph->addr_info_cb(ph->addr_info_cb_cls,
-                   &address,
-                   addr_active,
-                   pi->bandwidth_out,
-                   pi->bandwidth_in,
-                   &prop);
+  ph->addr_info_cb (ph->addr_info_cb_cls,
+                    &address,
+                    addr_active,
+                    pi->bandwidth_out,
+                    pi->bandwidth_in,
+                    &prop);
 }
 
 
@@ -368,48 +373,48 @@ handle_peer_information(void *cls,
  * @param rr the message
  */
 static void
-handle_reservation_result(void *cls,
-                          const struct ReservationResultMessage *rr)
+handle_reservation_result (void *cls,
+                           const struct ReservationResultMessage *rr)
 {
   struct GNUNET_ATS_PerformanceHandle *ph = cls;
   struct GNUNET_ATS_ReservationContext *rc;
   int32_t amount;
 
-  amount = ntohl(rr->amount);
+  amount = ntohl (rr->amount);
   rc = ph->reservation_head;
-  if (0 != GNUNET_memcmp(&rr->peer,
-                         &rc->peer))
-    {
-      GNUNET_break(0);
-      reconnect(ph);
-      return;
-    }
-  GNUNET_CONTAINER_DLL_remove(ph->reservation_head,
-                              ph->reservation_tail,
-                              rc);
+  if (0 != GNUNET_memcmp (&rr->peer,
+                          &rc->peer))
+  {
+    GNUNET_break (0);
+    reconnect (ph);
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (ph->reservation_head,
+                               ph->reservation_tail,
+                               rc);
   if ((0 == amount) ||
       (NULL != rc->rcb))
-    {
-      /* tell client if not cancelled */
-      if (NULL != rc->rcb)
-        rc->rcb(rc->rcb_cls,
-                &rr->peer,
-                amount,
-                GNUNET_TIME_relative_ntoh(rr->res_delay));
-      GNUNET_free(rc);
-      return;
-    }
+  {
+    /* tell client if not cancelled */
+    if (NULL != rc->rcb)
+      rc->rcb (rc->rcb_cls,
+               &rr->peer,
+               amount,
+               GNUNET_TIME_relative_ntoh (rr->res_delay));
+    GNUNET_free (rc);
+    return;
+  }
   /* amount non-zero, but client cancelled, consider undo! */
   if (GNUNET_YES != rc->undo)
-    {
-      GNUNET_free(rc);
-      return; /* do not try to undo failed undos or negative amounts */
-    }
-  GNUNET_free(rc);
-  (void)GNUNET_ATS_reserve_bandwidth(ph,
-                                     &rr->peer,
-                                     -amount,
-                                     NULL, NULL);
+  {
+    GNUNET_free (rc);
+    return;   /* do not try to undo failed undos or negative amounts */
+  }
+  GNUNET_free (rc);
+  (void) GNUNET_ATS_reserve_bandwidth (ph,
+                                       &rr->peer,
+                                       -amount,
+                                       NULL, NULL);
 }
 
 
@@ -421,25 +426,25 @@ handle_reservation_result(void *cls,
  * @return #GNUNET_OK if the message was well-formed
  */
 static int
-check_address_list(void *cls,
-                   const struct PeerInformationMessage *pi)
+check_address_list (void *cls,
+                    const struct PeerInformationMessage *pi)
 {
   const char *plugin_address;
   const char *plugin_name;
   uint16_t plugin_address_length;
   uint16_t plugin_name_length;
 
-  plugin_address_length = ntohs(pi->address_length);
-  plugin_name_length = ntohs(pi->plugin_name_length);
-  plugin_address = (const char *)&pi[1];
+  plugin_address_length = ntohs (pi->address_length);
+  plugin_name_length = ntohs (pi->plugin_name_length);
+  plugin_address = (const char *) &pi[1];
   plugin_name = &plugin_address[plugin_address_length];
   if ((plugin_address_length + plugin_name_length
-       + sizeof(struct PeerInformationMessage) != ntohs(pi->header.size)) ||
+       + sizeof(struct PeerInformationMessage) != ntohs (pi->header.size)) ||
       (plugin_name[plugin_name_length - 1] != '\0'))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -452,8 +457,8 @@ check_address_list(void *cls,
  * @param pi the message
  */
 static void
-handle_address_list(void *cls,
-                    const struct PeerInformationMessage *pi)
+handle_address_list (void *cls,
+                     const struct PeerInformationMessage *pi)
 {
   struct GNUNET_ATS_PerformanceHandle *ph = cls;
   struct GNUNET_ATS_AddressListHandle *alh;
@@ -469,49 +474,49 @@ handle_address_list(void *cls,
   uint32_t active;
   uint32_t id;
 
-  id = ntohl(pi->id);
-  active = ntohl(pi->address_active);
-  plugin_address_length = ntohs(pi->address_length);
-  plugin_name_length = ntohs(pi->plugin_name_length);
-  plugin_address = (const char *)&pi[1];
+  id = ntohl (pi->id);
+  active = ntohl (pi->address_active);
+  plugin_address_length = ntohs (pi->address_length);
+  plugin_name_length = ntohs (pi->plugin_name_length);
+  plugin_address = (const char *) &pi[1];
   plugin_name = &plugin_address[plugin_address_length];
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Received ATS_ADDRESSLIST_RESPONSE message for peer %s and plugin %s\n",
-      GNUNET_i2s(&pi->peer),
-      plugin_name);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received ATS_ADDRESSLIST_RESPONSE message for peer %s and plugin %s\n",
+       GNUNET_i2s (&pi->peer),
+       plugin_name);
 
   next = ph->addresslist_head;
   while (NULL != (alh = next))
-    {
-      next = alh->next;
-      if (alh->id == id)
-        break;
-    }
+  {
+    next = alh->next;
+    if (alh->id == id)
+      break;
+  }
   if (NULL == alh)
     return; /* was canceled */
 
-  memset(&allzeros, '\0', sizeof(allzeros));
-  if ((0 == GNUNET_is_zero(&pi->peer)) &&
+  memset (&allzeros, '\0', sizeof(allzeros));
+  if ((0 == GNUNET_is_zero (&pi->peer)) &&
       (0 == plugin_name_length) &&
       (0 == plugin_address_length))
-    {
-      /* Done */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Received last message for ATS_ADDRESSLIST_RESPONSE\n");
-      bandwidth_zero.value__ = htonl(0);
-      GNUNET_CONTAINER_DLL_remove(ph->addresslist_head,
-                                  ph->addresslist_tail,
-                                  alh);
-      if (NULL != alh->cb)
-        alh->cb(alh->cb_cls,
-                NULL,
-                GNUNET_NO,
-                bandwidth_zero,
-                bandwidth_zero,
-                NULL);
-      GNUNET_free(alh);
-      return;
-    }
+  {
+    /* Done */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Received last message for ATS_ADDRESSLIST_RESPONSE\n");
+    bandwidth_zero.value__ = htonl (0);
+    GNUNET_CONTAINER_DLL_remove (ph->addresslist_head,
+                                 ph->addresslist_tail,
+                                 alh);
+    if (NULL != alh->cb)
+      alh->cb (alh->cb_cls,
+               NULL,
+               GNUNET_NO,
+               bandwidth_zero,
+               bandwidth_zero,
+               NULL);
+    GNUNET_free (alh);
+    return;
+  }
 
   address.peer = pi->peer;
   address.address = plugin_address;
@@ -520,16 +525,16 @@ handle_address_list(void *cls,
   if (((GNUNET_YES == alh->all_addresses) ||
        (GNUNET_YES == active)) &&
       (NULL != alh->cb))
-    {
-      GNUNET_ATS_properties_ntoh(&prop,
-                                 &pi->properties);
-      alh->cb(alh->cb_cls,
-              &address,
-              active,
-              pi->bandwidth_out,
-              pi->bandwidth_in,
-              &prop);
-    }
+  {
+    GNUNET_ATS_properties_ntoh (&prop,
+                                &pi->properties);
+    alh->cb (alh->cb_cls,
+             &address,
+             active,
+             pi->bandwidth_out,
+             pi->bandwidth_in,
+             &prop);
+  }
 }
 
 
@@ -542,12 +547,12 @@ handle_address_list(void *cls,
  * @param error error code
  */
 static void
-mq_error_handler(void *cls,
-                 enum GNUNET_MQ_Error error)
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
 {
   struct GNUNET_ATS_PerformanceHandle *ph = cls;
 
-  do_reconnect(ph);
+  do_reconnect (ph);
 }
 
 
@@ -557,41 +562,41 @@ mq_error_handler(void *cls,
  * @param ph handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
+reconnect (struct GNUNET_ATS_PerformanceHandle *ph)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size(peer_information,
-                          GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION,
-                          struct PeerInformationMessage,
-                          ph),
-    GNUNET_MQ_hd_fixed_size(reservation_result,
-                            GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT,
-                            struct ReservationResultMessage,
-                            ph),
-    GNUNET_MQ_hd_var_size(address_list,
-                          GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE,
-                          struct PeerInformationMessage,
-                          ph),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (peer_information,
+                           GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION,
+                           struct PeerInformationMessage,
+                           ph),
+    GNUNET_MQ_hd_fixed_size (reservation_result,
+                             GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT,
+                             struct ReservationResultMessage,
+                             ph),
+    GNUNET_MQ_hd_var_size (address_list,
+                           GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE,
+                           struct PeerInformationMessage,
+                           ph),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_Envelope *env;
   struct ClientStartMessage *init;
 
-  GNUNET_assert(NULL == ph->mq);
-  ph->mq = GNUNET_CLIENT_connect(ph->cfg,
-                                 "ats",
-                                 handlers,
-                                 &mq_error_handler,
-                                 ph);
+  GNUNET_assert (NULL == ph->mq);
+  ph->mq = GNUNET_CLIENT_connect (ph->cfg,
+                                  "ats",
+                                  handlers,
+                                  &mq_error_handler,
+                                  ph);
   if (NULL == ph->mq)
     return;
-  env = GNUNET_MQ_msg(init,
-                      GNUNET_MESSAGE_TYPE_ATS_START);
-  init->start_flag = htonl((NULL == ph->addr_info_cb)
-                           ? START_FLAG_PERFORMANCE_NO_PIC
-                           : START_FLAG_PERFORMANCE_WITH_PIC);
-  GNUNET_MQ_send(ph->mq,
-                 env);
+  env = GNUNET_MQ_msg (init,
+                       GNUNET_MESSAGE_TYPE_ATS_START);
+  init->start_flag = htonl ((NULL == ph->addr_info_cb)
+                            ? START_FLAG_PERFORMANCE_NO_PIC
+                            : START_FLAG_PERFORMANCE_WITH_PIC);
+  GNUNET_MQ_send (ph->mq,
+                  env);
 }
 
 
@@ -605,22 +610,22 @@ reconnect(struct GNUNET_ATS_PerformanceHandle *ph)
  * @return ats performance context
  */
 struct GNUNET_ATS_PerformanceHandle *
-GNUNET_ATS_performance_init(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                            GNUNET_ATS_AddressInformationCallback addr_info_cb,
-                            void *addr_info_cb_cls)
+GNUNET_ATS_performance_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                             GNUNET_ATS_AddressInformationCallback addr_info_cb,
+                             void *addr_info_cb_cls)
 {
   struct GNUNET_ATS_PerformanceHandle *ph;
 
-  ph = GNUNET_new(struct GNUNET_ATS_PerformanceHandle);
+  ph = GNUNET_new (struct GNUNET_ATS_PerformanceHandle);
   ph->cfg = cfg;
   ph->addr_info_cb = addr_info_cb;
   ph->addr_info_cb_cls = addr_info_cb_cls;
-  reconnect(ph);
+  reconnect (ph);
   if (NULL == ph->mq)
-    {
-      GNUNET_free(ph);
-      return NULL;
-    }
+  {
+    GNUNET_free (ph);
+    return NULL;
+  }
   return ph;
 }
 
@@ -631,37 +636,37 @@ GNUNET_ATS_performance_init(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param ph handle
  */
 void
-GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
+GNUNET_ATS_performance_done (struct GNUNET_ATS_PerformanceHandle *ph)
 {
   struct GNUNET_ATS_ReservationContext *rc;
   struct GNUNET_ATS_AddressListHandle *alh;
 
   while (NULL != (alh = ph->addresslist_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(ph->addresslist_head,
-                                  ph->addresslist_tail,
-                                  alh);
-      GNUNET_free(alh);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (ph->addresslist_head,
+                                 ph->addresslist_tail,
+                                 alh);
+    GNUNET_free (alh);
+  }
   while (NULL != (rc = ph->reservation_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(ph->reservation_head,
-                                  ph->reservation_tail,
-                                  rc);
-      GNUNET_break(NULL == rc->rcb);
-      GNUNET_free(rc);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (ph->reservation_head,
+                                 ph->reservation_tail,
+                                 rc);
+    GNUNET_break (NULL == rc->rcb);
+    GNUNET_free (rc);
+  }
   if (NULL != ph->task)
-    {
-      GNUNET_SCHEDULER_cancel(ph->task);
-      ph->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ph->task);
+    ph->task = NULL;
+  }
   if (NULL != ph->mq)
-    {
-      GNUNET_MQ_destroy(ph->mq);
-      ph->mq = NULL;
-    }
-  GNUNET_free(ph);
+  {
+    GNUNET_MQ_destroy (ph->mq);
+    ph->mq = NULL;
+  }
+  GNUNET_free (ph);
 }
 
 
@@ -680,11 +685,11 @@ GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
  * @deprecated will be replaced soon
  */
 struct GNUNET_ATS_ReservationContext *
-GNUNET_ATS_reserve_bandwidth(struct GNUNET_ATS_PerformanceHandle *ph,
-                             const struct GNUNET_PeerIdentity *peer,
-                             int32_t amount,
-                             GNUNET_ATS_ReservationCallback rcb,
-                             void *rcb_cls)
+GNUNET_ATS_reserve_bandwidth (struct GNUNET_ATS_PerformanceHandle *ph,
+                              const struct GNUNET_PeerIdentity *peer,
+                              int32_t amount,
+                              GNUNET_ATS_ReservationCallback rcb,
+                              void *rcb_cls)
 {
   struct GNUNET_ATS_ReservationContext *rc;
   struct GNUNET_MQ_Envelope *env;
@@ -692,7 +697,7 @@ GNUNET_ATS_reserve_bandwidth(struct GNUNET_ATS_PerformanceHandle *ph,
 
   if (NULL == ph->mq)
     return NULL;
-  rc = GNUNET_new(struct GNUNET_ATS_ReservationContext);
+  rc = GNUNET_new (struct GNUNET_ATS_ReservationContext);
   rc->size = amount;
   rc->peer = *peer;
   rc->rcb = rcb;
@@ -700,15 +705,15 @@ GNUNET_ATS_reserve_bandwidth(struct GNUNET_ATS_PerformanceHandle *ph,
   if ((NULL != rcb) &&
       (amount > 0))
     rc->undo = GNUNET_YES;
-  GNUNET_CONTAINER_DLL_insert_tail(ph->reservation_head,
-                                   ph->reservation_tail,
-                                   rc);
-  env = GNUNET_MQ_msg(m,
-                      GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST);
-  m->amount = htonl(amount);
+  GNUNET_CONTAINER_DLL_insert_tail (ph->reservation_head,
+                                    ph->reservation_tail,
+                                    rc);
+  env = GNUNET_MQ_msg (m,
+                       GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST);
+  m->amount = htonl (amount);
   m->peer = *peer;
-  GNUNET_MQ_send(ph->mq,
-                 env);
+  GNUNET_MQ_send (ph->mq,
+                  env);
   return rc;
 }
 
@@ -719,7 +724,7 @@ GNUNET_ATS_reserve_bandwidth(struct GNUNET_ATS_PerformanceHandle *ph,
  * @param rc context returned by the original #GNUNET_ATS_reserve_bandwidth() call
  */
 void
-GNUNET_ATS_reserve_bandwidth_cancel(struct GNUNET_ATS_ReservationContext *rc)
+GNUNET_ATS_reserve_bandwidth_cancel (struct GNUNET_ATS_ReservationContext *rc)
 {
   rc->rcb = NULL;
 }
@@ -738,11 +743,12 @@ GNUNET_ATS_reserve_bandwidth_cancel(struct GNUNET_ATS_ReservationContext *rc)
  * @return ats performance context
  */
 struct GNUNET_ATS_AddressListHandle*
-GNUNET_ATS_performance_list_addresses(struct GNUNET_ATS_PerformanceHandle *ph,
-                                      const struct GNUNET_PeerIdentity *peer,
-                                      int all,
-                                      GNUNET_ATS_AddressInformationCallback infocb,
-                                      void *infocb_cls)
+GNUNET_ATS_performance_list_addresses (struct GNUNET_ATS_PerformanceHandle *ph,
+                                       const struct GNUNET_PeerIdentity *peer,
+                                       int all,
+                                       GNUNET_ATS_AddressInformationCallback
+                                       infocb,
+                                       void *infocb_cls)
 {
   struct GNUNET_ATS_AddressListHandle *alh;
   struct GNUNET_MQ_Envelope *env;
@@ -751,36 +757,36 @@ GNUNET_ATS_performance_list_addresses(struct GNUNET_ATS_PerformanceHandle *ph,
   if (NULL == ph->mq)
     return NULL;
   if (NULL == infocb)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  alh = GNUNET_new(struct GNUNET_ATS_AddressListHandle);
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  alh = GNUNET_new (struct GNUNET_ATS_AddressListHandle);
   alh->id = ph->id++;
   alh->cb = infocb;
   alh->cb_cls = infocb_cls;
   alh->ph = ph;
   alh->all_addresses = all;
   if (NULL == peer)
-    {
-      alh->all_peers = GNUNET_YES;
-    }
+  {
+    alh->all_peers = GNUNET_YES;
+  }
   else
-    {
-      alh->all_peers = GNUNET_NO;
-      alh->peer = *peer;
-    }
-  GNUNET_CONTAINER_DLL_insert(ph->addresslist_head,
-                              ph->addresslist_tail,
-                              alh);
-  env = GNUNET_MQ_msg(m,
-                      GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST);
-  m->all = htonl(all);
-  m->id = htonl(alh->id);
+  {
+    alh->all_peers = GNUNET_NO;
+    alh->peer = *peer;
+  }
+  GNUNET_CONTAINER_DLL_insert (ph->addresslist_head,
+                               ph->addresslist_tail,
+                               alh);
+  env = GNUNET_MQ_msg (m,
+                       GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST);
+  m->all = htonl (all);
+  m->id = htonl (alh->id);
   if (NULL != peer)
     m->peer = *peer;
-  GNUNET_MQ_send(ph->mq,
-                 env);
+  GNUNET_MQ_send (ph->mq,
+                  env);
   return alh;
 }
 
@@ -791,14 +797,15 @@ GNUNET_ATS_performance_list_addresses(struct GNUNET_ATS_PerformanceHandle *ph,
  * @param alh the handle of the request to cancel
  */
 void
-GNUNET_ATS_performance_list_addresses_cancel(struct GNUNET_ATS_AddressListHandle *alh)
+GNUNET_ATS_performance_list_addresses_cancel (struct
+                                              GNUNET_ATS_AddressListHandle *alh)
 {
   struct GNUNET_ATS_PerformanceHandle *ph = alh->ph;
 
-  GNUNET_CONTAINER_DLL_remove(ph->addresslist_head,
-                              ph->addresslist_tail,
-                              alh);
-  GNUNET_free(alh);
+  GNUNET_CONTAINER_DLL_remove (ph->addresslist_head,
+                               ph->addresslist_tail,
+                               alh);
+  GNUNET_free (alh);
 }
 
 
@@ -809,7 +816,7 @@ GNUNET_ATS_performance_list_addresses_cancel(struct GNUNET_ATS_AddressListHandle
  * @return a string or NULL if invalid
  */
 const char *
-GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
+GNUNET_ATS_print_preference_type (enum GNUNET_ATS_PreferenceKind type)
 {
   const char *prefs[] = GNUNET_ATS_PreferenceTypeString;
 
@@ -828,9 +835,11 @@ GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
  * @param ... #GNUNET_ATS_PREFERENCE_END-terminated specification of the desired changes
  */
 void
-GNUNET_ATS_performance_change_preference(struct GNUNET_ATS_PerformanceHandle *ph,
-                                         const struct GNUNET_PeerIdentity *peer,
-                                         ...)
+GNUNET_ATS_performance_change_preference (struct
+                                          GNUNET_ATS_PerformanceHandle *ph,
+                                          const struct
+                                          GNUNET_PeerIdentity *peer,
+                                          ...)
 {
   struct GNUNET_MQ_Envelope *env;
   struct ChangePreferenceMessage *m;
@@ -842,60 +851,61 @@ GNUNET_ATS_performance_change_preference(struct GNUNET_ATS_PerformanceHandle *ph
   if (NULL == ph->mq)
     return;
   count = 0;
-  va_start(ap, peer);
+  va_start (ap, peer);
   while (GNUNET_ATS_PREFERENCE_END !=
-         (kind = GNUNET_VA_ARG_ENUM(ap, GNUNET_ATS_PreferenceKind)))
+         (kind = GNUNET_VA_ARG_ENUM (ap, GNUNET_ATS_PreferenceKind)))
+  {
+    switch (kind)
     {
-      switch (kind)
-        {
-        case GNUNET_ATS_PREFERENCE_BANDWIDTH:
-          count++;
-          (void)va_arg(ap, double);
-          break;
-
-        case GNUNET_ATS_PREFERENCE_LATENCY:
-          count++;
-          (void)va_arg(ap, double);
-          break;
-
-        default:
-          GNUNET_assert(0);
-        }
+    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
+      count++;
+      (void) va_arg (ap, double);
+      break;
+
+    case GNUNET_ATS_PREFERENCE_LATENCY:
+      count++;
+      (void) va_arg (ap, double);
+      break;
+
+    default:
+      GNUNET_assert (0);
     }
-  va_end(ap);
-  env = GNUNET_MQ_msg_extra(m,
-                            count * sizeof(struct PreferenceInformation),
-                            GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE);
-  m->num_preferences = htonl(count);
+  }
+  va_end (ap);
+  env = GNUNET_MQ_msg_extra (m,
+                             count * sizeof(struct PreferenceInformation),
+                             GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE);
+  m->num_preferences = htonl (count);
   m->peer = *peer;
-  pi = (struct PreferenceInformation *)&m[1];
+  pi = (struct PreferenceInformation *) &m[1];
   count = 0;
-  va_start(ap, peer);
+  va_start (ap, peer);
   while (GNUNET_ATS_PREFERENCE_END != (kind =
-                                         GNUNET_VA_ARG_ENUM(ap, GNUNET_ATS_PreferenceKind)))
+                                         GNUNET_VA_ARG_ENUM (ap,
+                                                             GNUNET_ATS_PreferenceKind)))
+  {
+    pi[count].preference_kind = htonl (kind);
+    switch (kind)
     {
-      pi[count].preference_kind = htonl(kind);
-      switch (kind)
-        {
-        case GNUNET_ATS_PREFERENCE_BANDWIDTH:
-          pi[count].preference_value = (float)va_arg(ap, double);
+    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
+      pi[count].preference_value = (float) va_arg (ap, double);
 
-          count++;
-          break;
+      count++;
+      break;
 
-        case GNUNET_ATS_PREFERENCE_LATENCY:
-          pi[count].preference_value = (float)va_arg(ap, double);
+    case GNUNET_ATS_PREFERENCE_LATENCY:
+      pi[count].preference_value = (float) va_arg (ap, double);
 
-          count++;
-          break;
+      count++;
+      break;
 
-        default:
-          GNUNET_assert(0);
-        }
+    default:
+      GNUNET_assert (0);
     }
-  va_end(ap);
-  GNUNET_MQ_send(ph->mq,
-                 env);
+  }
+  va_end (ap);
+  GNUNET_MQ_send (ph->mq,
+                  env);
 }
 
 
@@ -909,10 +919,10 @@ GNUNET_ATS_performance_change_preference(struct GNUNET_ATS_PerformanceHandle *ph
  * @param ... #GNUNET_ATS_PREFERENCE_END-terminated specification of the desired changes
  */
 void
-GNUNET_ATS_performance_give_feedback(struct GNUNET_ATS_PerformanceHandle *ph,
-                                     const struct GNUNET_PeerIdentity *peer,
-                                     const struct GNUNET_TIME_Relative scope,
-                                     ...)
+GNUNET_ATS_performance_give_feedback (struct GNUNET_ATS_PerformanceHandle *ph,
+                                      const struct GNUNET_PeerIdentity *peer,
+                                      const struct GNUNET_TIME_Relative scope,
+                                      ...)
 {
   struct GNUNET_MQ_Envelope *env;
   struct FeedbackPreferenceMessage *m;
@@ -924,61 +934,62 @@ GNUNET_ATS_performance_give_feedback(struct GNUNET_ATS_PerformanceHandle *ph,
   if (NULL == ph->mq)
     return;
   count = 0;
-  va_start(ap, scope);
+  va_start (ap, scope);
   while (GNUNET_ATS_PREFERENCE_END !=
-         (kind = GNUNET_VA_ARG_ENUM(ap, GNUNET_ATS_PreferenceKind)))
+         (kind = GNUNET_VA_ARG_ENUM (ap, GNUNET_ATS_PreferenceKind)))
+  {
+    switch (kind)
     {
-      switch (kind)
-        {
-        case GNUNET_ATS_PREFERENCE_BANDWIDTH:
-          count++;
-          (void)va_arg(ap, double);
-          break;
-
-        case GNUNET_ATS_PREFERENCE_LATENCY:
-          count++;
-          (void)va_arg(ap, double);
-          break;
-
-        default:
-          GNUNET_assert(0);
-        }
+    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
+      count++;
+      (void) va_arg (ap, double);
+      break;
+
+    case GNUNET_ATS_PREFERENCE_LATENCY:
+      count++;
+      (void) va_arg (ap, double);
+      break;
+
+    default:
+      GNUNET_assert (0);
     }
-  va_end(ap);
-  env = GNUNET_MQ_msg_extra(m,
-                            count * sizeof(struct PreferenceInformation),
-                            GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK);
-  m->scope = GNUNET_TIME_relative_hton(scope);
-  m->num_feedback = htonl(count);
+  }
+  va_end (ap);
+  env = GNUNET_MQ_msg_extra (m,
+                             count * sizeof(struct PreferenceInformation),
+                             GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK);
+  m->scope = GNUNET_TIME_relative_hton (scope);
+  m->num_feedback = htonl (count);
   m->peer = *peer;
-  pi = (struct PreferenceInformation *)&m[1];
+  pi = (struct PreferenceInformation *) &m[1];
   count = 0;
-  va_start(ap, scope);
+  va_start (ap, scope);
   while (GNUNET_ATS_PREFERENCE_END != (kind =
-                                         GNUNET_VA_ARG_ENUM(ap, GNUNET_ATS_PreferenceKind)))
+                                         GNUNET_VA_ARG_ENUM (ap,
+                                                             GNUNET_ATS_PreferenceKind)))
+  {
+    pi[count].preference_kind = htonl (kind);
+    switch (kind)
     {
-      pi[count].preference_kind = htonl(kind);
-      switch (kind)
-        {
-        case GNUNET_ATS_PREFERENCE_BANDWIDTH:
-          pi[count].preference_value = (float)va_arg(ap, double);
+    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
+      pi[count].preference_value = (float) va_arg (ap, double);
 
-          count++;
-          break;
+      count++;
+      break;
 
-        case GNUNET_ATS_PREFERENCE_LATENCY:
-          pi[count].preference_value = (float)va_arg(ap, double);
+    case GNUNET_ATS_PREFERENCE_LATENCY:
+      pi[count].preference_value = (float) va_arg (ap, double);
 
-          count++;
-          break;
+      count++;
+      break;
 
-        default:
-          GNUNET_assert(0);
-        }
+    default:
+      GNUNET_assert (0);
     }
-  va_end(ap);
-  GNUNET_MQ_send(ph->mq,
-                 env);
+  }
+  va_end (ap);
+  GNUNET_MQ_send (ph->mq,
+                  env);
 }
 
 /* end of ats_api_performance.c */
diff --git a/src/ats/ats_api_scanner.c b/src/ats/ats_api_scanner.c
index 5c8ffe196..82114f888 100644
--- a/src/ats/ats_api_scanner.c
+++ b/src/ats/ats_api_scanner.c
@@ -33,14 +33,14 @@
  * @param hbo value read
  */
 void
-GNUNET_ATS_properties_hton(struct GNUNET_ATS_PropertiesNBO *nbo,
-                           const struct GNUNET_ATS_Properties *hbo)
+GNUNET_ATS_properties_hton (struct GNUNET_ATS_PropertiesNBO *nbo,
+                            const struct GNUNET_ATS_Properties *hbo)
 {
-  nbo->utilization_out = htonl(hbo->utilization_out);
-  nbo->utilization_in = htonl(hbo->utilization_in);
-  nbo->scope = htonl((uint32_t)hbo->scope);
-  nbo->distance = htonl(hbo->distance);
-  nbo->delay = GNUNET_TIME_relative_hton(hbo->delay);
+  nbo->utilization_out = htonl (hbo->utilization_out);
+  nbo->utilization_in = htonl (hbo->utilization_in);
+  nbo->scope = htonl ((uint32_t) hbo->scope);
+  nbo->distance = htonl (hbo->distance);
+  nbo->delay = GNUNET_TIME_relative_hton (hbo->delay);
 }
 
 
@@ -51,14 +51,14 @@ GNUNET_ATS_properties_hton(struct GNUNET_ATS_PropertiesNBO *nbo,
  * @param nbo value read
  */
 void
-GNUNET_ATS_properties_ntoh(struct GNUNET_ATS_Properties *hbo,
-                           const struct GNUNET_ATS_PropertiesNBO *nbo)
+GNUNET_ATS_properties_ntoh (struct GNUNET_ATS_Properties *hbo,
+                            const struct GNUNET_ATS_PropertiesNBO *nbo)
 {
-  hbo->utilization_out = ntohl(nbo->utilization_out);
-  hbo->utilization_in = ntohl(nbo->utilization_in);
-  hbo->scope = ntohl((uint32_t)nbo->scope);
-  hbo->distance = ntohl(nbo->distance);
-  hbo->delay = GNUNET_TIME_relative_ntoh(nbo->delay);
+  hbo->utilization_out = ntohl (nbo->utilization_out);
+  hbo->utilization_in = ntohl (nbo->utilization_in);
+  hbo->scope = ntohl ((uint32_t) nbo->scope);
+  hbo->distance = ntohl (nbo->distance);
+  hbo->delay = GNUNET_TIME_relative_ntoh (nbo->delay);
 }
 
 
diff --git a/src/ats/ats_api_scheduling.c b/src/ats/ats_api_scheduling.c
index f375be6a5..36162d12f 100644
--- a/src/ats/ats_api_scheduling.c
+++ b/src/ats/ats_api_scheduling.c
@@ -38,9 +38,10 @@
 /**
  * How frequently do we scan the interfaces for changes to the addresses?
  */
-#define INTERFACE_PROCESSING_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2)
+#define INTERFACE_PROCESSING_INTERVAL GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MINUTES, 2)
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-scheduling-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-scheduling-api", __VA_ARGS__)
 
 /**
  * Session ID we use if there is no session / slot.
@@ -53,7 +54,8 @@
  * doesn't matter if we have a session, any address that ATS is
  * allowed to suggest right now should be tracked.
  */
-struct GNUNET_ATS_AddressRecord {
+struct GNUNET_ATS_AddressRecord
+{
   /**
    * Scheduling handle this address record belongs to.
    */
@@ -97,7 +99,8 @@ struct GNUNET_ATS_AddressRecord {
 /**
  * Handle to the ATS subsystem for bandwidth/transport scheduling information.
  */
-struct GNUNET_ATS_SchedulingHandle {
+struct GNUNET_ATS_SchedulingHandle
+{
   /**
    * Our configuration.
    */
@@ -149,7 +152,7 @@ struct GNUNET_ATS_SchedulingHandle {
  * @param sh handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_SchedulingHandle *sh);
+reconnect (struct GNUNET_ATS_SchedulingHandle *sh);
 
 
 /**
@@ -158,12 +161,12 @@ reconnect(struct GNUNET_ATS_SchedulingHandle *sh);
  * @param cls handle to use to re-connect.
  */
 static void
-reconnect_task(void *cls)
+reconnect_task (void *cls)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = cls;
 
   sh->task = NULL;
-  reconnect(sh);
+  reconnect (sh);
 }
 
 
@@ -173,21 +176,21 @@ reconnect_task(void *cls)
  * @param sh our handle
  */
 static void
-force_reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
+force_reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
 {
   if (NULL != sh->mq)
-    {
-      GNUNET_MQ_destroy(sh->mq);
-      sh->mq = NULL;
-    }
-  sh->suggest_cb(sh->suggest_cb_cls,
-                 NULL, NULL, NULL,
-                 GNUNET_BANDWIDTH_ZERO,
-                 GNUNET_BANDWIDTH_ZERO);
-  sh->backoff = GNUNET_TIME_STD_BACKOFF(sh->backoff);
-  sh->task = GNUNET_SCHEDULER_add_delayed(sh->backoff,
-                                          &reconnect_task,
-                                          sh);
+  {
+    GNUNET_MQ_destroy (sh->mq);
+    sh->mq = NULL;
+  }
+  sh->suggest_cb (sh->suggest_cb_cls,
+                  NULL, NULL, NULL,
+                  GNUNET_BANDWIDTH_ZERO,
+                  GNUNET_BANDWIDTH_ZERO);
+  sh->backoff = GNUNET_TIME_STD_BACKOFF (sh->backoff);
+  sh->task = GNUNET_SCHEDULER_add_delayed (sh->backoff,
+                                           &reconnect_task,
+                                           sh);
 }
 
 
@@ -200,37 +203,37 @@ force_reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
  * @return the session object (or NULL)
  */
 static struct GNUNET_ATS_AddressRecord *
-find_session(struct GNUNET_ATS_SchedulingHandle *sh,
-             uint32_t session_id,
-             const struct GNUNET_PeerIdentity *peer)
+find_session (struct GNUNET_ATS_SchedulingHandle *sh,
+              uint32_t session_id,
+              const struct GNUNET_PeerIdentity *peer)
 {
   struct GNUNET_ATS_AddressRecord *ar;
 
   if (session_id >= sh->session_array_size)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   if (0 == session_id)
     return NULL;
   ar = sh->session_array[session_id];
   if (NULL == ar)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   if (NULL == ar->address)
-    {
-      /* address was destroyed in the meantime, this can happen
-         as we communicate asynchronously with the ATS service. */
-      return NULL;
-    }
-  if (0 != GNUNET_memcmp(peer,
-                         &ar->address->peer))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    /* address was destroyed in the meantime, this can happen
+       as we communicate asynchronously with the ATS service. */
+    return NULL;
+  }
+  if (0 != GNUNET_memcmp (peer,
+                          &ar->address->peer))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   return ar;
 }
 
@@ -242,27 +245,27 @@ find_session(struct GNUNET_ATS_SchedulingHandle *sh,
  * @return an unused slot, but never NOT_FOUND (0)
  */
 static uint32_t
-find_empty_session_slot(struct GNUNET_ATS_SchedulingHandle *sh)
+find_empty_session_slot (struct GNUNET_ATS_SchedulingHandle *sh)
 {
   static uint32_t off;
   uint32_t i;
 
-  GNUNET_assert(0 != sh->session_array_size);
+  GNUNET_assert (0 != sh->session_array_size);
   i = 0;
   while (((NOT_FOUND == off) ||
           (NULL != sh->session_array[off % sh->session_array_size])) &&
          (i < sh->session_array_size))
-    {
-      off++;
-      i++;
-    }
+  {
+    off++;
+    i++;
+  }
   if ((NOT_FOUND != off % sh->session_array_size) &&
       (NULL == sh->session_array[off % sh->session_array_size]))
     return off;
   i = sh->session_array_size;
-  GNUNET_array_grow(sh->session_array,
-                    sh->session_array_size,
-                    sh->session_array_size * 2);
+  GNUNET_array_grow (sh->session_array,
+                     sh->session_array_size,
+                     sh->session_array_size * 2);
   return i;
 }
 
@@ -276,26 +279,26 @@ find_empty_session_slot(struct GNUNET_ATS_SchedulingHandle *sh)
  * @return the session id or NOT_FOUND for error
  */
 static uint32_t
-find_session_id(struct GNUNET_ATS_SchedulingHandle *sh,
-                struct GNUNET_ATS_Session *session,
-                const struct GNUNET_HELLO_Address *address)
+find_session_id (struct GNUNET_ATS_SchedulingHandle *sh,
+                 struct GNUNET_ATS_Session *session,
+                 const struct GNUNET_HELLO_Address *address)
 {
   uint32_t i;
 
   if (NULL == address)
-    {
-      GNUNET_break(0);
-      return NOT_FOUND;
-    }
+  {
+    GNUNET_break (0);
+    return NOT_FOUND;
+  }
   for (i = 1; i < sh->session_array_size; i++)
     if ((NULL != sh->session_array[i]) &&
         (GNUNET_NO == sh->session_array[i]->in_destroy) &&
         ((session == sh->session_array[i]->session) ||
          (NULL == sh->session_array[i]->session)) &&
-        (0 == GNUNET_memcmp(&address->peer,
-                            &sh->session_array[i]->address->peer)) &&
-        (0 == GNUNET_HELLO_address_cmp(address,
-                                       sh->session_array[i]->address)))
+        (0 == GNUNET_memcmp (&address->peer,
+                             &sh->session_array[i]->address->peer)) &&
+        (0 == GNUNET_HELLO_address_cmp (address,
+                                        sh->session_array[i]->address)))
       return i;
   return NOT_FOUND;
 }
@@ -309,29 +312,29 @@ find_session_id(struct GNUNET_ATS_SchedulingHandle *sh,
  * @param session_id identifies session that is no longer valid
  */
 static void
-release_session(struct GNUNET_ATS_SchedulingHandle *sh,
-                uint32_t session_id)
+release_session (struct GNUNET_ATS_SchedulingHandle *sh,
+                 uint32_t session_id)
 {
   struct GNUNET_ATS_AddressRecord *ar;
 
   if (NOT_FOUND == session_id)
     return;
   if (session_id >= sh->session_array_size)
-    {
-      GNUNET_break(0);
-      force_reconnect(sh);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    force_reconnect (sh);
+    return;
+  }
   /* this slot should have been removed from remove_session before */
   ar = sh->session_array[session_id];
   if (NULL != ar->session)
-    {
-      GNUNET_break(0);
-      force_reconnect(sh);
-      return;
-    }
-  GNUNET_HELLO_address_free(ar->address);
-  GNUNET_free(ar);
+  {
+    GNUNET_break (0);
+    force_reconnect (sh);
+    return;
+  }
+  GNUNET_HELLO_address_free (ar->address);
+  GNUNET_free (ar);
   sh->session_array[session_id] = NULL;
 }
 
@@ -344,15 +347,15 @@ release_session(struct GNUNET_ATS_SchedulingHandle *sh,
  * @param srm message received
  */
 static void
-handle_ats_session_release(void *cls,
-                           const struct GNUNET_ATS_SessionReleaseMessage *srm)
+handle_ats_session_release (void *cls,
+                            const struct GNUNET_ATS_SessionReleaseMessage *srm)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = cls;
 
   /* Note: peer field in srm not necessary right now,
      but might be good to have in the future */
-  release_session(sh,
-                  ntohl(srm->session_id));
+  release_session (sh,
+                   ntohl (srm->session_id));
 }
 
 
@@ -364,71 +367,71 @@ handle_ats_session_release(void *cls,
  * @param m message received
  */
 static void
-handle_ats_address_suggestion(void *cls,
-                              const struct AddressSuggestionMessage *m)
+handle_ats_address_suggestion (void *cls,
+                               const struct AddressSuggestionMessage *m)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = cls;
   struct GNUNET_ATS_AddressRecord *ar;
   uint32_t session_id;
 
-  session_id = ntohl(m->session_id);
+  session_id = ntohl (m->session_id);
   if (0 == session_id)
-    {
-      GNUNET_break(0);
-      force_reconnect(sh);
-      return;
-    }
-  ar = find_session(sh,
-                    session_id,
-                    &m->peer);
+  {
+    GNUNET_break (0);
+    force_reconnect (sh);
+    return;
+  }
+  ar = find_session (sh,
+                     session_id,
+                     &m->peer);
   if (NULL == ar)
-    {
-      GNUNET_break(0);
-      force_reconnect(sh);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    force_reconnect (sh);
+    return;
+  }
   if (NULL == sh->suggest_cb)
     return;
   if (GNUNET_YES == ar->in_destroy)
+  {
+    /* ignore suggestion, as this address is dying, unless BW is 0,
+       in that case signal 'disconnect' via BW 0 */
+    if ((0 == ntohl (m->bandwidth_out.value__)) &&
+        (0 == ntohl (m->bandwidth_in.value__)))
     {
-      /* ignore suggestion, as this address is dying, unless BW is 0,
-         in that case signal 'disconnect' via BW 0 */
-      if ((0 == ntohl(m->bandwidth_out.value__)) &&
-          (0 == ntohl(m->bandwidth_in.value__)))
-        {
-          LOG(GNUNET_ERROR_TYPE_DEBUG,
-              "ATS suggests disconnect from peer `%s' with BW %u/%u\n",
-              GNUNET_i2s(&ar->address->peer),
-              (unsigned int)ntohl(m->bandwidth_out.value__),
-              (unsigned int)ntohl(m->bandwidth_in.value__));
-          sh->suggest_cb(sh->suggest_cb_cls,
-                         &m->peer,
-                         NULL,
-                         NULL,
-                         m->bandwidth_out,
-                         m->bandwidth_in);
-        }
-      return;
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "ATS suggests disconnect from peer `%s' with BW %u/%u\n",
+           GNUNET_i2s (&ar->address->peer),
+           (unsigned int) ntohl (m->bandwidth_out.value__),
+           (unsigned int) ntohl (m->bandwidth_in.value__));
+      sh->suggest_cb (sh->suggest_cb_cls,
+                      &m->peer,
+                      NULL,
+                      NULL,
+                      m->bandwidth_out,
+                      m->bandwidth_in);
     }
+    return;
+  }
   if ((NULL == ar->session) &&
-      (GNUNET_HELLO_address_check_option(ar->address,
-                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND)))
-    {
-      GNUNET_break(0);
-      return;
-    }
+      (GNUNET_HELLO_address_check_option (ar->address,
+                                          GNUNET_HELLO_ADDRESS_INFO_INBOUND)))
+  {
+    GNUNET_break (0);
+    return;
+  }
   sh->backoff = GNUNET_TIME_UNIT_ZERO;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "ATS suggests address slot %u for peer `%s' using plugin %s\n",
-      ar->slot,
-      GNUNET_i2s(&ar->address->peer),
-      ar->address->transport_name);
-  sh->suggest_cb(sh->suggest_cb_cls,
-                 &m->peer,
-                 ar->address,
-                 ar->session,
-                 m->bandwidth_out,
-                 m->bandwidth_in);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "ATS suggests address slot %u for peer `%s' using plugin %s\n",
+       ar->slot,
+       GNUNET_i2s (&ar->address->peer),
+       ar->address->transport_name);
+  sh->suggest_cb (sh->suggest_cb_cls,
+                  &m->peer,
+                  ar->address,
+                  ar->session,
+                  m->bandwidth_out,
+                  m->bandwidth_in);
 }
 
 
@@ -440,15 +443,15 @@ handle_ats_address_suggestion(void *cls,
  * @param error details about the error
  */
 static void
-error_handler(void *cls,
-              enum GNUNET_MQ_Error error)
+error_handler (void *cls,
+               enum GNUNET_MQ_Error error)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = cls;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "ATS connection died (code %d), reconnecting\n",
-      (int)error);
-  force_reconnect(sh);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "ATS connection died (code %d), reconnecting\n",
+       (int) error);
+  force_reconnect (sh);
 }
 
 
@@ -460,8 +463,8 @@ error_handler(void *cls,
  * @param ar the address to inform the ATS service about
  */
 static void
-send_add_address_message(struct GNUNET_ATS_SchedulingHandle *sh,
-                         const struct GNUNET_ATS_AddressRecord *ar)
+send_add_address_message (struct GNUNET_ATS_SchedulingHandle *sh,
+                          const struct GNUNET_ATS_AddressRecord *ar)
 {
   struct GNUNET_MQ_Envelope *ev;
   struct AddressAddMessage *m;
@@ -471,32 +474,32 @@ send_add_address_message(struct GNUNET_ATS_SchedulingHandle *sh,
 
   if (NULL == sh->mq)
     return; /* disconnected, skip for now */
-  GNUNET_break(GNUNET_NT_UNSPECIFIED != ar->properties.scope);
-  namelen = strlen(ar->address->transport_name) + 1;
+  GNUNET_break (GNUNET_NT_UNSPECIFIED != ar->properties.scope);
+  namelen = strlen (ar->address->transport_name) + 1;
   msize = ar->address->address_length + namelen;
-  ev = GNUNET_MQ_msg_extra(m, msize, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD);
+  ev = GNUNET_MQ_msg_extra (m, msize, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD);
   m->peer = ar->address->peer;
-  m->address_length = htons(ar->address->address_length);
-  m->address_local_info = htonl((uint32_t)ar->address->local_info);
-  m->plugin_name_length = htons(namelen);
-  m->session_id = htonl(ar->slot);
+  m->address_length = htons (ar->address->address_length);
+  m->address_local_info = htonl ((uint32_t) ar->address->local_info);
+  m->plugin_name_length = htons (namelen);
+  m->session_id = htonl (ar->slot);
   m->properties = ar->properties;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Adding address for peer `%s', plugin `%s', session %p slot %u\n",
-      GNUNET_i2s(&ar->address->peer),
-      ar->address->transport_name,
-      ar->session,
-      ar->slot);
-  pm = (char *)&m[1];
-  GNUNET_memcpy(pm,
-                ar->address->address,
-                ar->address->address_length);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding address for peer `%s', plugin `%s', session %p slot %u\n",
+       GNUNET_i2s (&ar->address->peer),
+       ar->address->transport_name,
+       ar->session,
+       ar->slot);
+  pm = (char *) &m[1];
+  GNUNET_memcpy (pm,
+                 ar->address->address,
+                 ar->address->address_length);
   if (NULL != ar->address->transport_name)
-    GNUNET_memcpy(&pm[ar->address->address_length],
-                  ar->address->transport_name,
-                  namelen);
-  GNUNET_MQ_send(sh->mq, ev);
+    GNUNET_memcpy (&pm[ar->address->address_length],
+                   ar->address->transport_name,
+                   namelen);
+  GNUNET_MQ_send (sh->mq, ev);
 }
 
 
@@ -506,51 +509,51 @@ send_add_address_message(struct GNUNET_ATS_SchedulingHandle *sh,
  * @param sh handle to use to re-connect.
  */
 static void
-reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
+reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_fixed_size(ats_session_release,
-                            GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE,
-                            struct GNUNET_ATS_SessionReleaseMessage,
-                            sh),
-    GNUNET_MQ_hd_fixed_size(ats_address_suggestion,
-                            GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION,
-                            struct AddressSuggestionMessage,
-                            sh),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_fixed_size (ats_session_release,
+                             GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE,
+                             struct GNUNET_ATS_SessionReleaseMessage,
+                             sh),
+    GNUNET_MQ_hd_fixed_size (ats_address_suggestion,
+                             GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION,
+                             struct AddressSuggestionMessage,
+                             sh),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_Envelope *ev;
   struct ClientStartMessage *init;
   unsigned int i;
   struct GNUNET_ATS_AddressRecord *ar;
 
-  GNUNET_assert(NULL == sh->mq);
-  sh->mq = GNUNET_CLIENT_connect(sh->cfg,
-                                 "ats",
-                                 handlers,
-                                 &error_handler,
-                                 sh);
+  GNUNET_assert (NULL == sh->mq);
+  sh->mq = GNUNET_CLIENT_connect (sh->cfg,
+                                  "ats",
+                                  handlers,
+                                  &error_handler,
+                                  sh);
   if (NULL == sh->mq)
-    {
-      GNUNET_break(0);
-      force_reconnect(sh);
-      return;
-    }
-  ev = GNUNET_MQ_msg(init,
-                     GNUNET_MESSAGE_TYPE_ATS_START);
-  init->start_flag = htonl(START_FLAG_SCHEDULING);
-  GNUNET_MQ_send(sh->mq, ev);
+  {
+    GNUNET_break (0);
+    force_reconnect (sh);
+    return;
+  }
+  ev = GNUNET_MQ_msg (init,
+                      GNUNET_MESSAGE_TYPE_ATS_START);
+  init->start_flag = htonl (START_FLAG_SCHEDULING);
+  GNUNET_MQ_send (sh->mq, ev);
   if (NULL == sh->mq)
     return;
   for (i = 0; i < sh->session_array_size; i++)
-    {
-      ar = sh->session_array[i];
-      if (NULL == ar)
-        continue;
-      send_add_address_message(sh, ar);
-      if (NULL == sh->mq)
-        return;
-    }
+  {
+    ar = sh->session_array[i];
+    if (NULL == ar)
+      continue;
+    send_add_address_message (sh, ar);
+    if (NULL == sh->mq)
+      return;
+  }
 }
 
 
@@ -563,20 +566,20 @@ reconnect(struct GNUNET_ATS_SchedulingHandle *sh)
  * @return ats context
  */
 struct GNUNET_ATS_SchedulingHandle *
-GNUNET_ATS_scheduling_init(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                           GNUNET_ATS_AddressSuggestionCallback suggest_cb,
-                           void *suggest_cb_cls)
+GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                            GNUNET_ATS_AddressSuggestionCallback suggest_cb,
+                            void *suggest_cb_cls)
 {
   struct GNUNET_ATS_SchedulingHandle *sh;
 
-  sh = GNUNET_new(struct GNUNET_ATS_SchedulingHandle);
+  sh = GNUNET_new (struct GNUNET_ATS_SchedulingHandle);
   sh->cfg = cfg;
   sh->suggest_cb = suggest_cb;
   sh->suggest_cb_cls = suggest_cb_cls;
-  GNUNET_array_grow(sh->session_array,
-                    sh->session_array_size,
-                    4);
-  reconnect(sh);
+  GNUNET_array_grow (sh->session_array,
+                     sh->session_array_size,
+                     4);
+  reconnect (sh);
   return sh;
 }
 
@@ -587,34 +590,34 @@ GNUNET_ATS_scheduling_init(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param sh handle to release
  */
 void
-GNUNET_ATS_scheduling_done(struct GNUNET_ATS_SchedulingHandle *sh)
+GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh)
 {
   struct GNUNET_ATS_AddressRecord *ar;
   unsigned int i;
 
   if (NULL != sh->mq)
-    {
-      GNUNET_MQ_destroy(sh->mq);
-      sh->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (sh->mq);
+    sh->mq = NULL;
+  }
   if (NULL != sh->task)
-    {
-      GNUNET_SCHEDULER_cancel(sh->task);
-      sh->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sh->task);
+    sh->task = NULL;
+  }
   for (i = 0; i < sh->session_array_size; i++)
+  {
+    if (NULL != (ar = sh->session_array[i]))
     {
-      if (NULL != (ar = sh->session_array[i]))
-        {
-          GNUNET_HELLO_address_free(ar->address);
-          GNUNET_free(ar);
-          sh->session_array[i] = NULL;
-        }
+      GNUNET_HELLO_address_free (ar->address);
+      GNUNET_free (ar);
+      sh->session_array[i] = NULL;
     }
-  GNUNET_array_grow(sh->session_array,
-                    sh->session_array_size,
-                    0);
-  GNUNET_free(sh);
+  }
+  GNUNET_array_grow (sh->session_array,
+                     sh->session_array_size,
+                     0);
+  GNUNET_free (sh);
 }
 
 
@@ -631,10 +634,10 @@ GNUNET_ATS_scheduling_done(struct GNUNET_ATS_SchedulingHandle *sh)
  *         on error (i.e. ATS knows this exact address already)
  */
 struct GNUNET_ATS_AddressRecord *
-GNUNET_ATS_address_add(struct GNUNET_ATS_SchedulingHandle *sh,
-                       const struct GNUNET_HELLO_Address *address,
-                       struct GNUNET_ATS_Session *session,
-                       const struct GNUNET_ATS_Properties *prop)
+GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
+                        const struct GNUNET_HELLO_Address *address,
+                        struct GNUNET_ATS_Session *session,
+                        const struct GNUNET_ATS_Properties *prop)
 {
   struct GNUNET_ATS_AddressRecord *ar;
   size_t namelen;
@@ -642,42 +645,43 @@ GNUNET_ATS_address_add(struct GNUNET_ATS_SchedulingHandle *sh,
   uint32_t s;
 
   if (NULL == address)
-    {
-      /* we need a valid address */
-      GNUNET_break(0);
-      return NULL;
-    }
-  GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
-  namelen = strlen(address->transport_name) + 1;
+  {
+    /* we need a valid address */
+    GNUNET_break (0);
+    return NULL;
+  }
+  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
+  namelen = strlen (address->transport_name) + 1;
   msize = address->address_length + namelen;
-  if ((msize + sizeof(struct AddressUpdateMessage) >= GNUNET_MAX_MESSAGE_SIZE) ||
+  if ((msize + sizeof(struct AddressUpdateMessage) >=
+       GNUNET_MAX_MESSAGE_SIZE) ||
       (address->address_length >= GNUNET_MAX_MESSAGE_SIZE) ||
       (namelen >= GNUNET_MAX_MESSAGE_SIZE))
-    {
-      /* address too large for us, this should not happen */
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    /* address too large for us, this should not happen */
+    GNUNET_break (0);
+    return NULL;
+  }
 
   if (NOT_FOUND !=
-      find_session_id(sh,
-                      session,
-                      address))
-    {
-      /* Already existing, nothing todo, but this should not happen */
-      GNUNET_break(0);
-      return NULL;
-    }
-  s = find_empty_session_slot(sh);
-  ar = GNUNET_new(struct GNUNET_ATS_AddressRecord);
+      find_session_id (sh,
+                       session,
+                       address))
+  {
+    /* Already existing, nothing todo, but this should not happen */
+    GNUNET_break (0);
+    return NULL;
+  }
+  s = find_empty_session_slot (sh);
+  ar = GNUNET_new (struct GNUNET_ATS_AddressRecord);
   ar->sh = sh;
   ar->slot = s;
   ar->session = session;
-  ar->address = GNUNET_HELLO_address_copy(address);
-  GNUNET_ATS_properties_hton(&ar->properties,
-                             prop);
+  ar->address = GNUNET_HELLO_address_copy (address);
+  GNUNET_ATS_properties_hton (&ar->properties,
+                              prop);
   sh->session_array[s] = ar;
-  send_add_address_message(sh, ar);
+  send_add_address_message (sh, ar);
   return ar;
 }
 
@@ -689,10 +693,10 @@ GNUNET_ATS_address_add(struct GNUNET_ATS_SchedulingHandle *sh,
  * @param session session handle
  */
 void
-GNUNET_ATS_address_add_session(struct GNUNET_ATS_AddressRecord *ar,
-                               struct GNUNET_ATS_Session *session)
+GNUNET_ATS_address_add_session (struct GNUNET_ATS_AddressRecord *ar,
+                                struct GNUNET_ATS_Session *session)
 {
-  GNUNET_break(NULL == ar->session);
+  GNUNET_break (NULL == ar->session);
   ar->session = session;
 }
 
@@ -710,17 +714,17 @@ GNUNET_ATS_address_add_session(struct GNUNET_ATS_AddressRecord *ar,
  *                    use it still to establish a new session
  */
 int
-GNUNET_ATS_address_del_session(struct GNUNET_ATS_AddressRecord *ar,
-                               struct GNUNET_ATS_Session *session)
+GNUNET_ATS_address_del_session (struct GNUNET_ATS_AddressRecord *ar,
+                                struct GNUNET_ATS_Session *session)
 {
-  GNUNET_assert(session == ar->session);
+  GNUNET_assert (session == ar->session);
   ar->session = NULL;
-  if (GNUNET_HELLO_address_check_option(ar->address,
-                                        GNUNET_HELLO_ADDRESS_INFO_INBOUND))
-    {
-      GNUNET_ATS_address_destroy(ar);
-      return GNUNET_YES;
-    }
+  if (GNUNET_HELLO_address_check_option (ar->address,
+                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND))
+  {
+    GNUNET_ATS_address_destroy (ar);
+    return GNUNET_YES;
+  }
   return GNUNET_NO;
 }
 
@@ -737,30 +741,30 @@ GNUNET_ATS_address_del_session(struct GNUNET_ATS_AddressRecord *ar,
  * @param prop performance data for the address
  */
 void
-GNUNET_ATS_address_update(struct GNUNET_ATS_AddressRecord *ar,
-                          const struct GNUNET_ATS_Properties *prop)
+GNUNET_ATS_address_update (struct GNUNET_ATS_AddressRecord *ar,
+                           const struct GNUNET_ATS_Properties *prop)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = ar->sh;
   struct GNUNET_MQ_Envelope *ev;
   struct AddressUpdateMessage *m;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Updating address for peer `%s', plugin `%s', session %p slot %u\n",
-      GNUNET_i2s(&ar->address->peer),
-      ar->address->transport_name,
-      ar->session,
-      ar->slot);
-  GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
-  GNUNET_ATS_properties_hton(&ar->properties,
-                             prop);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Updating address for peer `%s', plugin `%s', session %p slot %u\n",
+       GNUNET_i2s (&ar->address->peer),
+       ar->address->transport_name,
+       ar->session,
+       ar->slot);
+  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
+  GNUNET_ATS_properties_hton (&ar->properties,
+                              prop);
   if (NULL == sh->mq)
     return; /* disconnected, skip for now */
-  ev = GNUNET_MQ_msg(m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE);
-  m->session_id = htonl(ar->slot);
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE);
+  m->session_id = htonl (ar->slot);
   m->peer = ar->address->peer;
   m->properties = ar->properties;
-  GNUNET_MQ_send(sh->mq,
-                 ev);
+  GNUNET_MQ_send (sh->mq,
+                  ev);
 }
 
 
@@ -770,27 +774,27 @@ GNUNET_ATS_address_update(struct GNUNET_ATS_AddressRecord *ar,
  * @param ar address to destroy
  */
 void
-GNUNET_ATS_address_destroy(struct GNUNET_ATS_AddressRecord *ar)
+GNUNET_ATS_address_destroy (struct GNUNET_ATS_AddressRecord *ar)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = ar->sh;
   struct GNUNET_MQ_Envelope *ev;
   struct AddressDestroyedMessage *m;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Deleting address for peer `%s', plugin `%s', slot %u session %p\n",
-      GNUNET_i2s(&ar->address->peer),
-      ar->address->transport_name,
-      ar->slot,
-      ar->session);
-  GNUNET_break(NULL == ar->session);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Deleting address for peer `%s', plugin `%s', slot %u session %p\n",
+       GNUNET_i2s (&ar->address->peer),
+       ar->address->transport_name,
+       ar->slot,
+       ar->session);
+  GNUNET_break (NULL == ar->session);
   ar->session = NULL;
   ar->in_destroy = GNUNET_YES;
   if (NULL == sh->mq)
     return;
-  ev = GNUNET_MQ_msg(m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED);
-  m->session_id = htonl(ar->slot);
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED);
+  m->session_id = htonl (ar->slot);
   m->peer = ar->address->peer;
-  GNUNET_MQ_send(sh->mq, ev);
+  GNUNET_MQ_send (sh->mq, ev);
 }
 
 
diff --git a/src/ats/gnunet-ats-solver-eval.c b/src/ats/gnunet-ats-solver-eval.c
index 4068cffce..9866ca929 100644
--- a/src/ats/gnunet-ats-solver-eval.c
+++ b/src/ats/gnunet-ats-solver-eval.c
@@ -85,35 +85,35 @@ static int opt_disable_normalization;
 static int res;
 
 static void
-end_now();
+end_now ();
 
 
 static char *
-print_generator_type(enum GeneratorType g)
+print_generator_type (enum GeneratorType g)
 {
   switch (g)
-    {
-    case GNUNET_ATS_TEST_TG_CONSTANT:
-      return "CONSTANT";
+  {
+  case GNUNET_ATS_TEST_TG_CONSTANT:
+    return "CONSTANT";
 
-    case GNUNET_ATS_TEST_TG_LINEAR:
-      return "LINEAR";
+  case GNUNET_ATS_TEST_TG_LINEAR:
+    return "LINEAR";
 
-    case GNUNET_ATS_TEST_TG_RANDOM:
-      return "RANDOM";
+  case GNUNET_ATS_TEST_TG_RANDOM:
+    return "RANDOM";
 
-    case GNUNET_ATS_TEST_TG_SINUS:
-      return "SINUS";
+  case GNUNET_ATS_TEST_TG_SINUS:
+    return "SINUS";
 
-    default:
-      return "INVALID";
-      break;
-    }
+  default:
+    return "INVALID";
+    break;
+  }
 }
 
 
 static struct TestPeer *
-find_peer_by_id(int id)
+find_peer_by_id (int id)
 {
   struct TestPeer *cur;
 
@@ -124,18 +124,18 @@ find_peer_by_id(int id)
 }
 
 static struct TestPeer *
-find_peer_by_pid(const struct GNUNET_PeerIdentity *pid)
+find_peer_by_pid (const struct GNUNET_PeerIdentity *pid)
 {
   struct TestPeer *cur;
 
   for (cur = peer_head; NULL != cur; cur = cur->next)
-    if (0 == GNUNET_memcmp(&cur->peer_id, pid))
+    if (0 == GNUNET_memcmp (&cur->peer_id, pid))
       return cur;
   return NULL;
 }
 
 static struct TestAddress *
-find_address_by_id(struct TestPeer *peer, int aid)
+find_address_by_id (struct TestPeer *peer, int aid)
 {
   struct TestAddress *cur;
 
@@ -150,7 +150,7 @@ find_address_by_id(struct TestPeer *peer, int aid)
  * Logging
  */
 void
-GNUNET_ATS_solver_logging_now(struct LoggingHandle *l)
+GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
 {
   struct LoggingTimeStep *lts;
   struct TestPeer *cur;
@@ -159,111 +159,114 @@ GNUNET_ATS_solver_logging_now(struct LoggingHandle *l)
   struct LoggingAddress *log_a;
   int c;
 
-  lts = GNUNET_new(struct LoggingTimeStep);
-  GNUNET_CONTAINER_DLL_insert_tail(l->head, l->tail, lts);
-  lts->timestamp = GNUNET_TIME_absolute_get();
+  lts = GNUNET_new (struct LoggingTimeStep);
+  GNUNET_CONTAINER_DLL_insert_tail (l->head, l->tail, lts);
+  lts->timestamp = GNUNET_TIME_absolute_get ();
   if (NULL == lts->prev)
     lts->delta = GNUNET_TIME_UNIT_ZERO;
   else
-    lts->delta = GNUNET_TIME_absolute_get_duration(lts->prev->timestamp);
+    lts->delta = GNUNET_TIME_absolute_get_duration (lts->prev->timestamp);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Logging %llu, delta %llu\n",
-             lts->timestamp.abs_value_us, lts->delta.rel_value_us);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Logging %llu, delta %llu\n",
+              lts->timestamp.abs_value_us, lts->delta.rel_value_us);
 
 
   /* Store logging data here */
   for (cur = peer_head; NULL != cur; cur = cur->next)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Logging peer id %llu\n", cur->id);
-
-      log_p = GNUNET_new(struct LoggingPeer);
-      log_p->id = cur->id;
-      log_p->peer_id = cur->peer_id;
-      log_p->is_requested = cur->is_requested;
-      for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
-        {
-          log_p->pref_abs[c] = cur->pref_abs[c];
-          log_p->pref_norm[c] = cur->pref_norm[c];
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "\t %s = %.2f %.2f [abs/rel]\n",
-                     GNUNET_ATS_print_preference_type(c),
-                     log_p->pref_abs[c], log_p->pref_norm[c]);
-        }
-      GNUNET_CONTAINER_DLL_insert_tail(lts->head, lts->tail, log_p);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Logging peer id %llu\n", cur->id);
+
+    log_p = GNUNET_new (struct LoggingPeer);
+    log_p->id = cur->id;
+    log_p->peer_id = cur->peer_id;
+    log_p->is_requested = cur->is_requested;
+    for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
+    {
+      log_p->pref_abs[c] = cur->pref_abs[c];
+      log_p->pref_norm[c] = cur->pref_norm[c];
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t %s = %.2f %.2f [abs/rel]\n",
+                  GNUNET_ATS_print_preference_type (c),
+                  log_p->pref_abs[c], log_p->pref_norm[c]);
+    }
+    GNUNET_CONTAINER_DLL_insert_tail (lts->head, lts->tail, log_p);
+
+    for (cur_addr = cur->addr_head; NULL != cur_addr; cur_addr = cur_addr->next)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Logging peer id %llu address %llu\n",
+                  cur->id, cur_addr->aid);
+      log_a = GNUNET_new (struct LoggingAddress);
+      log_a->aid = cur_addr->aid;
+      log_a->active = cur_addr->ats_addr->active;
+      log_a->network = cur_addr->network;
+      log_a->assigned_bw_in = cur_addr->ats_addr->assigned_bw_in;
+      log_a->assigned_bw_out = cur_addr->ats_addr->assigned_bw_out;
+      for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
+      {
+        log_a->prop_abs[c] = cur_addr->prop_abs[c];
+        log_a->prop_norm[c] = cur_addr->prop_norm[c];
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "\t %s = %.2f %.2f [abs/rel]\n",
+                    GNUNET_ATS_print_property_type (c),
+                    log_a->prop_abs[c],
+                    log_a->prop_norm[c]);
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t Active = %i\n", log_a->active);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t BW in = %llu\n",
+                  log_a->assigned_bw_in);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "\t BW out = %llu\n",
+                  log_a->assigned_bw_out);
 
-      for (cur_addr = cur->addr_head; NULL != cur_addr; cur_addr = cur_addr->next)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     "Logging peer id %llu address %llu\n",
-                     cur->id, cur_addr->aid);
-          log_a = GNUNET_new(struct LoggingAddress);
-          log_a->aid = cur_addr->aid;
-          log_a->active = cur_addr->ats_addr->active;
-          log_a->network = cur_addr->network;
-          log_a->assigned_bw_in = cur_addr->ats_addr->assigned_bw_in;
-          log_a->assigned_bw_out = cur_addr->ats_addr->assigned_bw_out;
-          for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
-            {
-              log_a->prop_abs[c] = cur_addr->prop_abs[c];
-              log_a->prop_norm[c] = cur_addr->prop_norm[c];
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                         "\t %s = %.2f %.2f [abs/rel]\n",
-                         GNUNET_ATS_print_property_type(c),
-                         log_a->prop_abs[c],
-                         log_a->prop_norm[c]);
-            }
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "\t Active = %i\n", log_a->active);
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "\t BW in = %llu\n", log_a->assigned_bw_in);
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO, "\t BW out = %llu\n", log_a->assigned_bw_out);
-
-          GNUNET_CONTAINER_DLL_insert_tail(log_p->addr_head, log_p->addr_tail, log_a);
-        }
+      GNUNET_CONTAINER_DLL_insert_tail (log_p->addr_head, log_p->addr_tail,
+                                        log_a);
     }
+  }
 }
 
 
 static void
-logging_task(void *cls)
+logging_task (void *cls)
 {
   struct LoggingHandle *l = cls;
 
   l->logging_task = NULL;
-  GNUNET_ATS_solver_logging_now(l);
-  l->logging_task = GNUNET_SCHEDULER_add_delayed(l->log_freq,
-                                                 &logging_task,
-                                                 l);
+  GNUNET_ATS_solver_logging_now (l);
+  l->logging_task = GNUNET_SCHEDULER_add_delayed (l->log_freq,
+                                                  &logging_task,
+                                                  l);
 }
 
 struct LoggingHandle *
-GNUNET_ATS_solver_logging_start(struct GNUNET_TIME_Relative freq)
+GNUNET_ATS_solver_logging_start (struct GNUNET_TIME_Relative freq)
 {
   struct LoggingHandle *l;
 
-  l = GNUNET_new(struct LoggingHandle);
+  l = GNUNET_new (struct LoggingHandle);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Start logging every  %s\n",
-             GNUNET_STRINGS_relative_time_to_string(freq, GNUNET_NO));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Start logging every  %s\n",
+              GNUNET_STRINGS_relative_time_to_string (freq, GNUNET_NO));
   l->log_freq = freq;
-  l->logging_task = GNUNET_SCHEDULER_add_now(&logging_task, l);
+  l->logging_task = GNUNET_SCHEDULER_add_now (&logging_task, l);
   return l;
 }
 
 void
-GNUNET_ATS_solver_logging_stop(struct LoggingHandle *l)
+GNUNET_ATS_solver_logging_stop (struct LoggingHandle *l)
 {
   if (NULL != l->logging_task)
-    GNUNET_SCHEDULER_cancel(l->logging_task);
+    GNUNET_SCHEDULER_cancel (l->logging_task);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stop logging\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stop logging\n");
 
   l->logging_task = NULL;
 }
 
 static struct LoggingFileHandle *
-find_logging_file_handle(struct LoggingFileHandle *lf_head,
-                         struct LoggingFileHandle *lf_tail,
-                         int peer_id, int address_id)
+find_logging_file_handle (struct LoggingFileHandle *lf_head,
+                          struct LoggingFileHandle *lf_tail,
+                          int peer_id, int address_id)
 {
   struct LoggingFileHandle *res;
 
@@ -274,8 +277,9 @@ find_logging_file_handle(struct LoggingFileHandle *lf_head,
 }
 
 void
-GNUNET_ATS_solver_logging_write_to_disk(struct LoggingHandle *l, int add_time_stamp,
-                                        char *output_dir)
+GNUNET_ATS_solver_logging_write_to_disk (struct LoggingHandle *l, int
+                                         add_time_stamp,
+                                         char *output_dir)
 {
   struct LoggingTimeStep *lts;
   struct LoggingPeer *log_p;
@@ -284,164 +288,169 @@ GNUNET_ATS_solver_logging_write_to_disk(struct LoggingHandle *l, int add_time_st
   struct LoggingFileHandle *lf_tail;
   struct LoggingFileHandle *cur;
   struct LoggingFileHandle *next;
-  char * filename;
-  char * datastring;
-  char * propstring;
-  char * propstring_tmp;
-  char * prefstring;
-  char * prefstring_tmp;
+  char *filename;
+  char *datastring;
+  char *propstring;
+  char *propstring_tmp;
+  char *prefstring;
+  char *prefstring_tmp;
   int c;
   int use_dir;
 
   use_dir = GNUNET_NO;
   if (NULL != output_dir)
+  {
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (output_dir))
     {
-      if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(output_dir))
-        {
-          fprintf(stderr, "Failed to create directory `%s'\n", output_dir);
-          return;
-        }
-      else
-        {
-          fprintf(stderr, "Created directory `%s'\n", output_dir);
-          use_dir = GNUNET_YES;
-        }
+      fprintf (stderr, "Failed to create directory `%s'\n", output_dir);
+      return;
     }
+    else
+    {
+      fprintf (stderr, "Created directory `%s'\n", output_dir);
+      use_dir = GNUNET_YES;
+    }
+  }
 
   lf_head = NULL;
   lf_tail = NULL;
 
   for (lts = l->head; NULL != lts; lts = lts->next)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Writing log step %llu\n",
+                (long long unsigned int) lts->timestamp.abs_value_us);
+
+    for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Writing log step %llu\n",
-                 (long long unsigned int)lts->timestamp.abs_value_us);
+      for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
+      {
+        cur = find_logging_file_handle (lf_head, lf_tail, log_p->id,
+                                        log_a->aid);
+        if (NULL == cur)
+        {
+          cur = GNUNET_new (struct LoggingFileHandle);
+          cur->aid = log_a->aid;
+          cur->pid = log_p->id;
+
+          if (GNUNET_YES == add_time_stamp)
+            GNUNET_asprintf (&filename, "%s%s%s_%s_p%u_a%u_%llu.log",
+                             (GNUNET_YES == use_dir) ? output_dir : "",
+                             (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
+                             e->log_prefix,
+                             opt_solver,
+                             cur->pid,
+                             cur->aid,
+                             l->head->timestamp.abs_value_us);
+          else
+            GNUNET_asprintf (&filename, "%s%s%s_%s_p%u_a%u.log",
+                             (GNUNET_YES == use_dir) ? output_dir : "",
+                             (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
+                             e->log_prefix,
+                             opt_solver,
+                             cur->pid,
+                             cur->aid);
+
+          fprintf (stderr,
+                   "Add writing log data for peer %llu address %llu to file `%s'\n",
+                   cur->pid, cur->aid, filename);
+
+
+          cur->f_hd = GNUNET_DISK_file_open (filename,
+                                             GNUNET_DISK_OPEN_READWRITE
+                                             | GNUNET_DISK_OPEN_CREATE
+                                             | GNUNET_DISK_OPEN_TRUNCATE,
+                                             GNUNET_DISK_PERM_USER_READ
+                                             | GNUNET_DISK_PERM_USER_WRITE
+                                             | GNUNET_DISK_PERM_GROUP_READ
+                                             | GNUNET_DISK_PERM_OTHER_READ);
+          if (NULL == cur->f_hd)
+          {
+            fprintf (stderr, "Cannot open `%s' to write log data!\n", filename);
+            GNUNET_free (filename);
+            GNUNET_free (cur);
+            goto cleanup;
+          }
+          GNUNET_free (filename);
+          GNUNET_CONTAINER_DLL_insert (lf_head, lf_tail, cur);
+
+          GNUNET_asprintf (&datastring,
+                           "#time delta;log duration;peer_requested;addr net; addr_active; bw in; bw out; " \
+                           "UTILIZATION_UP [abs/rel]; UTILIZATION_UP; UTILIZATION_DOWN; UTILIZATION_DOWN; " \
+                           "UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_DOWN; UTILIZATION_PAYLOAD_DOWN;" \
+                           "DELAY; DELAY; " \
+                           "DISTANCE ;DISTANCE ; COST_WAN; COST_WAN; COST_LAN; COST_LAN; " \
+                           "COST_WLAN; COST_WLAN;COST_BT; COST_BT; PREF BW abs; PREF BW rel; PREF LATENCY abs; PREF LATENCY rel;\n");
+          GNUNET_DISK_file_write (cur->f_hd, datastring, strlen (datastring));
+          GNUNET_free (datastring);
+        }
 
-      for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
+        prefstring = GNUNET_strdup ("");
+        for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
         {
-          for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
-            {
-              cur = find_logging_file_handle(lf_head, lf_tail, log_p->id,
-                                             log_a->aid);
-              if (NULL == cur)
-                {
-                  cur = GNUNET_new(struct LoggingFileHandle);
-                  cur->aid = log_a->aid;
-                  cur->pid = log_p->id;
-
-                  if (GNUNET_YES == add_time_stamp)
-                    GNUNET_asprintf(&filename, "%s%s%s_%s_p%u_a%u_%llu.log",
-                                    (GNUNET_YES == use_dir) ? output_dir : "",
-                                    (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
-                                    e->log_prefix,
-                                    opt_solver,
-                                    cur->pid,
-                                    cur->aid,
-                                    l->head->timestamp.abs_value_us);
-                  else
-                    GNUNET_asprintf(&filename, "%s%s%s_%s_p%u_a%u.log",
-                                    (GNUNET_YES == use_dir) ? output_dir : "",
-                                    (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
-                                    e->log_prefix,
-                                    opt_solver,
-                                    cur->pid,
-                                    cur->aid);
-
-                  fprintf(stderr, "Add writing log data for peer %llu address %llu to file `%s'\n",
-                          cur->pid, cur->aid, filename);
-
-
-                  cur->f_hd = GNUNET_DISK_file_open(filename,
-                                                    GNUNET_DISK_OPEN_READWRITE |
-                                                    GNUNET_DISK_OPEN_CREATE |
-                                                    GNUNET_DISK_OPEN_TRUNCATE,
-                                                    GNUNET_DISK_PERM_USER_READ |
-                                                    GNUNET_DISK_PERM_USER_WRITE |
-                                                    GNUNET_DISK_PERM_GROUP_READ |
-                                                    GNUNET_DISK_PERM_OTHER_READ);
-                  if (NULL == cur->f_hd)
-                    {
-                      fprintf(stderr, "Cannot open `%s' to write log data!\n", filename);
-                      GNUNET_free(filename);
-                      GNUNET_free(cur);
-                      goto cleanup;
-                    }
-                  GNUNET_free(filename);
-                  GNUNET_CONTAINER_DLL_insert(lf_head, lf_tail, cur);
-
-                  GNUNET_asprintf(&datastring, "#time delta;log duration;peer_requested;addr net; addr_active; bw in; bw out; " \
-                                  "UTILIZATION_UP [abs/rel]; UTILIZATION_UP; UTILIZATION_DOWN; UTILIZATION_DOWN; " \
-                                  "UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_DOWN; UTILIZATION_PAYLOAD_DOWN;" \
-                                  "DELAY; DELAY; " \
-                                  "DISTANCE ;DISTANCE ; COST_WAN; COST_WAN; COST_LAN; COST_LAN; " \
-                                  "COST_WLAN; COST_WLAN;COST_BT; COST_BT; PREF BW abs; PREF BW rel; PREF LATENCY abs; PREF LATENCY rel;\n");
-                  GNUNET_DISK_file_write(cur->f_hd, datastring, strlen(datastring));
-                  GNUNET_free(datastring);
-                }
-
-              prefstring = GNUNET_strdup("");
-              for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
-                {
-                  /*
-                     fprintf(stderr,"\t %s = %.2f %.2f [abs/rel]\n",
-                      GNUNET_ATS_print_preference_type(c),
-                      log_p->pref_abs[c], log_p->pref_norm[c]);
-                   */
-                  GNUNET_asprintf(&prefstring_tmp, "%s;%.3f;%.3f",
-                                  prefstring, log_p->pref_abs[c], log_p->pref_norm[c]);
-
-
-                  GNUNET_free(prefstring);
-                  prefstring = GNUNET_strdup(prefstring_tmp);
-                  GNUNET_free(prefstring_tmp);
-                }
-
-
-              propstring = GNUNET_strdup("");
-              for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
-                {
-                  if (GNUNET_ATS_NETWORK_TYPE == c)
-                    continue;
-                  /*
-                     fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n",
-                      GNUNET_ATS_print_property_type(c),
-                      log_a->prop_abs[c], log_a->prop_norm[c]);*/
-                  GNUNET_asprintf(&propstring_tmp, "%s%.3f;%.3f;",
-                                  propstring,
-                                  log_a->prop_abs[c],
-                                  log_a->prop_norm[c]);
-                  GNUNET_free(propstring);
-                  propstring = GNUNET_strdup(propstring_tmp);
-                  GNUNET_free(propstring_tmp);
-                }
-              GNUNET_asprintf(&datastring, "%llu;%llu;%u;%u;%i;%u;%u;%s;%s\n",
-                              GNUNET_TIME_absolute_get_difference(l->head->timestamp,
-                                                                  lts->timestamp).rel_value_us / 1000, lts->delta,
-                              log_p->is_requested, log_a->network, log_a->active,
-                              log_a->assigned_bw_in, log_a->assigned_bw_out, propstring,
-                              prefstring);
-
-              GNUNET_DISK_file_write(cur->f_hd, datastring, strlen(datastring));
-              GNUNET_free(datastring);
-              GNUNET_free(prefstring);
-              GNUNET_free(propstring);
-            }
+          /*
+             fprintf(stderr,"\t %s = %.2f %.2f [abs/rel]\n",
+              GNUNET_ATS_print_preference_type(c),
+              log_p->pref_abs[c], log_p->pref_norm[c]);
+           */
+          GNUNET_asprintf (&prefstring_tmp, "%s;%.3f;%.3f",
+                           prefstring, log_p->pref_abs[c], log_p->pref_norm[c]);
+
+
+          GNUNET_free (prefstring);
+          prefstring = GNUNET_strdup (prefstring_tmp);
+          GNUNET_free (prefstring_tmp);
         }
+
+
+        propstring = GNUNET_strdup ("");
+        for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
+        {
+          if (GNUNET_ATS_NETWORK_TYPE == c)
+            continue;
+          /*
+             fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n",
+              GNUNET_ATS_print_property_type(c),
+              log_a->prop_abs[c], log_a->prop_norm[c]);*/
+          GNUNET_asprintf (&propstring_tmp, "%s%.3f;%.3f;",
+                           propstring,
+                           log_a->prop_abs[c],
+                           log_a->prop_norm[c]);
+          GNUNET_free (propstring);
+          propstring = GNUNET_strdup (propstring_tmp);
+          GNUNET_free (propstring_tmp);
+        }
+        GNUNET_asprintf (&datastring, "%llu;%llu;%u;%u;%i;%u;%u;%s;%s\n",
+                         GNUNET_TIME_absolute_get_difference (
+                           l->head->timestamp,
+                           lts->timestamp).
+                         rel_value_us / 1000, lts->delta,
+                         log_p->is_requested, log_a->network, log_a->active,
+                         log_a->assigned_bw_in, log_a->assigned_bw_out,
+                         propstring,
+                         prefstring);
+
+        GNUNET_DISK_file_write (cur->f_hd, datastring, strlen (datastring));
+        GNUNET_free (datastring);
+        GNUNET_free (prefstring);
+        GNUNET_free (propstring);
+      }
     }
+  }
 
 cleanup:
   next = lf_head;
   for (cur = next; NULL != cur; cur = next)
-    {
-      next = cur->next;
-      GNUNET_CONTAINER_DLL_remove(lf_head, lf_tail, cur);
-      if (NULL != cur->f_hd)
-        GNUNET_DISK_file_close(cur->f_hd);
-      GNUNET_free(cur);
-    }
+  {
+    next = cur->next;
+    GNUNET_CONTAINER_DLL_remove (lf_head, lf_tail, cur);
+    if (NULL != cur->f_hd)
+      GNUNET_DISK_file_close (cur->f_hd);
+    GNUNET_free (cur);
+  }
 }
 
 void
-GNUNET_ATS_solver_logging_eval(struct LoggingHandle *l)
+GNUNET_ATS_solver_logging_eval (struct LoggingHandle *l)
 {
   struct LoggingTimeStep *lts;
   struct LoggingPeer *log_p;
@@ -449,43 +458,43 @@ GNUNET_ATS_solver_logging_eval(struct LoggingHandle *l)
   int c;
 
   for (lts = l->head; NULL != lts; lts = lts->next)
+  {
+    fprintf (stderr, "Log step %llu %llu: \n",
+             (long long unsigned int) lts->timestamp.abs_value_us,
+             (long long unsigned int) lts->delta.rel_value_us);
+
+    for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
     {
-      fprintf(stderr, "Log step %llu %llu: \n",
-              (long long unsigned int)lts->timestamp.abs_value_us,
-              (long long unsigned int)lts->delta.rel_value_us);
+      fprintf (stderr, "\tLogging peer pid %llu\n", log_p->id);
+      for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
+      {
+        fprintf (stderr, "\t %s = %.2f %.2f [abs/rel]\n",
+                 GNUNET_ATS_print_preference_type (c),
+                 log_p->pref_abs[c], log_p->pref_norm[c]);
+      }
 
-      for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
+      for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
+      {
+        fprintf (stderr, "\tPeer pid %llu address %llu: %u %u %u\n",
+                 log_p->id, log_a->aid, log_a->active,
+                 log_a->assigned_bw_in,
+                 log_a->assigned_bw_out);
+
+        for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
         {
-          fprintf(stderr, "\tLogging peer pid %llu\n", log_p->id);
-          for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
-            {
-              fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n",
-                      GNUNET_ATS_print_preference_type(c),
-                      log_p->pref_abs[c], log_p->pref_norm[c]);
-            }
-
-          for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
-            {
-              fprintf(stderr, "\tPeer pid %llu address %llu: %u %u %u\n",
-                      log_p->id, log_a->aid, log_a->active,
-                      log_a->assigned_bw_in,
-                      log_a->assigned_bw_out);
-
-              for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
-                {
-                  if (GNUNET_ATS_NETWORK_TYPE == c)
-                    continue;
-                  fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n",
-                          GNUNET_ATS_print_property_type(c),
-                          log_a->prop_abs[c], log_a->prop_norm[c]);
-                }
-            }
+          if (GNUNET_ATS_NETWORK_TYPE == c)
+            continue;
+          fprintf (stderr, "\t %s = %.2f %.2f [abs/rel]\n",
+                   GNUNET_ATS_print_property_type (c),
+                   log_a->prop_abs[c], log_a->prop_norm[c]);
         }
+      }
     }
+  }
 }
 
 void
-GNUNET_ATS_solver_logging_free(struct LoggingHandle *l)
+GNUNET_ATS_solver_logging_free (struct LoggingHandle *l)
 {
   struct LoggingTimeStep *lts_cur;
   struct LoggingTimeStep *lts_next;
@@ -495,37 +504,38 @@ GNUNET_ATS_solver_logging_free(struct LoggingHandle *l)
   struct LoggingAddress *log_a_next;
 
   if (NULL != l->logging_task)
-    GNUNET_SCHEDULER_cancel(l->logging_task);
+    GNUNET_SCHEDULER_cancel (l->logging_task);
   l->logging_task = NULL;
 
   lts_next = l->head;
   while (NULL != (lts_cur = lts_next))
-    {
-      lts_next = lts_cur->next;
-
-      log_p_next = lts_cur->head;
-      while (NULL != (log_p_cur = log_p_next))
-        {
-          log_p_next = log_p_cur->next;
+  {
+    lts_next = lts_cur->next;
 
-          log_a_next = log_p_cur->addr_head;
-          while (NULL != (log_a_cur = log_a_next))
-            {
-              log_a_next = log_a_cur->next;
+    log_p_next = lts_cur->head;
+    while (NULL != (log_p_cur = log_p_next))
+    {
+      log_p_next = log_p_cur->next;
 
-              GNUNET_CONTAINER_DLL_remove(log_p_cur->addr_head, log_p_cur->addr_tail, log_a_cur);
-              GNUNET_free(log_a_cur);
-            }
+      log_a_next = log_p_cur->addr_head;
+      while (NULL != (log_a_cur = log_a_next))
+      {
+        log_a_next = log_a_cur->next;
 
-          GNUNET_CONTAINER_DLL_remove(lts_cur->head, lts_cur->tail, log_p_cur);
-          GNUNET_free(log_p_cur);
-        }
+        GNUNET_CONTAINER_DLL_remove (log_p_cur->addr_head, log_p_cur->addr_tail,
+                                     log_a_cur);
+        GNUNET_free (log_a_cur);
+      }
 
-      GNUNET_CONTAINER_DLL_remove(l->head, l->tail, lts_cur);
-      GNUNET_free(lts_cur);
+      GNUNET_CONTAINER_DLL_remove (lts_cur->head, lts_cur->tail, log_p_cur);
+      GNUNET_free (log_p_cur);
     }
 
-  GNUNET_free(l);
+    GNUNET_CONTAINER_DLL_remove (l->head, l->tail, lts_cur);
+    GNUNET_free (lts_cur);
+  }
+
+  GNUNET_free (l);
 }
 
 /**
@@ -536,7 +546,7 @@ static struct PropertyGenerator *prop_gen_tail;
 
 
 static double
-get_property(struct PropertyGenerator *pg)
+get_property (struct PropertyGenerator *pg)
 {
   struct GNUNET_TIME_Relative time_delta;
   double delta_value;
@@ -544,62 +554,66 @@ get_property(struct PropertyGenerator *pg)
 
   /* Calculate the current preference value */
   switch (pg->type)
-    {
-    case GNUNET_ATS_TEST_TG_CONSTANT:
-      pref_value = pg->base_value;
-      break;
-
-    case GNUNET_ATS_TEST_TG_LINEAR:
-      time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start);
-      /* Calculate point of time in the current period */
-      time_delta.rel_value_us = time_delta.rel_value_us %
-                                pg->duration_period.rel_value_us;
-      delta_value = ((double)time_delta.rel_value_us /
-                     pg->duration_period.rel_value_us) * (pg->max_value - pg->base_value);
-      if ((pg->max_value < pg->base_value) &&
-          ((pg->max_value - pg->base_value) > pg->base_value))
-        {
-          /* This will cause an underflow */
-          GNUNET_break(0);
-        }
-      pref_value = pg->base_value + delta_value;
-      break;
-
-    case GNUNET_ATS_TEST_TG_RANDOM:
-      delta_value = (double)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                                     10000 * (pg->max_value - pg->base_value)) / 10000;
-      pref_value = pg->base_value + delta_value;
-      break;
-
-    case GNUNET_ATS_TEST_TG_SINUS:
-      time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start);
-      /* Calculate point of time in the current period */
-      time_delta.rel_value_us = time_delta.rel_value_us %
-                                pg->duration_period.rel_value_us;
-      if ((pg->max_value - pg->base_value) > pg->base_value)
-        {
-          /* This will cause an underflow for second half of sinus period,
-           * will be detected in general when experiments are loaded */
-          GNUNET_break(0);
-        }
-      delta_value = (pg->max_value - pg->base_value) *
-                    sin((2 * M_PI) / ((double)pg->duration_period.rel_value_us) *
-                        time_delta.rel_value_us);
-      pref_value = pg->base_value + delta_value;
-      break;
-
-    default:
-      pref_value = 0.0;
-      break;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Current property value is %f\n",
-             pref_value);
+  {
+  case GNUNET_ATS_TEST_TG_CONSTANT:
+    pref_value = pg->base_value;
+    break;
+
+  case GNUNET_ATS_TEST_TG_LINEAR:
+    time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
+    /* Calculate point of time in the current period */
+    time_delta.rel_value_us = time_delta.rel_value_us
+                              % pg->duration_period.rel_value_us;
+    delta_value = ((double) time_delta.rel_value_us
+                   / pg->duration_period.rel_value_us) * (pg->max_value
+                                                          - pg->base_value);
+    if ((pg->max_value < pg->base_value) &&
+        ((pg->max_value - pg->base_value) > pg->base_value))
+    {
+      /* This will cause an underflow */
+      GNUNET_break (0);
+    }
+    pref_value = pg->base_value + delta_value;
+    break;
+
+  case GNUNET_ATS_TEST_TG_RANDOM:
+    delta_value = (double) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                     10000 * (pg->max_value
+                                                              - pg->base_value))
+                  / 10000;
+    pref_value = pg->base_value + delta_value;
+    break;
+
+  case GNUNET_ATS_TEST_TG_SINUS:
+    time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
+    /* Calculate point of time in the current period */
+    time_delta.rel_value_us = time_delta.rel_value_us
+                              % pg->duration_period.rel_value_us;
+    if ((pg->max_value - pg->base_value) > pg->base_value)
+    {
+      /* This will cause an underflow for second half of sinus period,
+       * will be detected in general when experiments are loaded */
+      GNUNET_break (0);
+    }
+    delta_value = (pg->max_value - pg->base_value)
+                  * sin ((2 * M_PI)
+                         / ((double) pg->duration_period.rel_value_us)
+                         * time_delta.rel_value_us);
+    pref_value = pg->base_value + delta_value;
+    break;
+
+  default:
+    pref_value = 0.0;
+    break;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Current property value is %f\n",
+              pref_value);
   return pref_value;
 }
 
 
 static void
-set_prop_task(void *cls)
+set_prop_task (void *cls)
 {
   struct PropertyGenerator *pg = cls;
   struct TestPeer *p;
@@ -609,58 +623,63 @@ set_prop_task(void *cls)
 
   pg->set_task = NULL;
 
-  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains_value(sh->addresses,
-                                                                &pg->test_peer->peer_id, pg->test_address->ats_addr))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting property generation for unknown address [%u:%u]\n",
-                 pg->peer, pg->address_id);
-      return;
-    }
-  if (NULL == (p = find_peer_by_id(pg->peer)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting property generation for unknown peer %u\n",
-                 pg->peer);
-      return;
-    }
-  if (NULL == (a = find_address_by_id(p, pg->address_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting property generation for unknown peer %u\n",
-                 pg->peer);
-      return;
-    }
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains_value (sh->addresses,
+                                                                 &pg->test_peer
+                                                                 ->peer_id,
+                                                                 pg->
+                                                                 test_address->
+                                                                 ats_addr))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting property generation for unknown address [%u:%u]\n",
+                pg->peer, pg->address_id);
+    return;
+  }
+  if (NULL == (p = find_peer_by_id (pg->peer)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting property generation for unknown peer %u\n",
+                pg->peer);
+    return;
+  }
+  if (NULL == (a = find_address_by_id (p, pg->address_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting property generation for unknown peer %u\n",
+                pg->peer);
+    return;
+  }
 
-  prop_value = get_property(pg);
+  prop_value = get_property (pg);
   a->prop_abs[pg->ats_property] = prop_value;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Setting property for peer [%u] address [%u] for %s to %f\n",
-             pg->peer, pg->address_id,
-             GNUNET_ATS_print_property_type(pg->ats_property), prop_value);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Setting property for peer [%u] address [%u] for %s to %f\n",
+              pg->peer, pg->address_id,
+              GNUNET_ATS_print_property_type (pg->ats_property), prop_value);
 
-  atsi.type = htonl(pg->ats_property);
-  atsi.value = htonl((uint32_t)prop_value);
+  atsi.type = htonl (pg->ats_property);
+  atsi.value = htonl ((uint32_t) prop_value);
 
   /* set performance here! */
-  sh->sf->s_bulk_start(sh->sf->cls);
+  sh->sf->s_bulk_start (sh->sf->cls);
   if (GNUNET_YES == opt_disable_normalization)
-    {
-      a->prop_abs[pg->ats_property] = prop_value;
-      a->prop_norm[pg->ats_property] = prop_value;
-      sh->sf->s_address_update_property(sh->sf->cls, a->ats_addr,
-                                        pg->ats_property, prop_value, prop_value);
-    }
+  {
+    a->prop_abs[pg->ats_property] = prop_value;
+    a->prop_norm[pg->ats_property] = prop_value;
+    sh->sf->s_address_update_property (sh->sf->cls, a->ats_addr,
+                                       pg->ats_property, prop_value,
+                                       prop_value);
+  }
   else
-    GAS_normalization_update_property(pg->test_address->ats_addr, &atsi, 1);
-  sh->sf->s_bulk_stop(sh->sf->cls);
+    GAS_normalization_update_property (pg->test_address->ats_addr, &atsi, 1);
+  sh->sf->s_bulk_stop (sh->sf->cls);
 
-  pg->set_task = GNUNET_SCHEDULER_add_delayed(pg->frequency,
-                                              &set_prop_task, pg);
+  pg->set_task = GNUNET_SCHEDULER_add_delayed (pg->frequency,
+                                               &set_prop_task, pg);
 }
 
 
@@ -668,36 +687,36 @@ set_prop_task(void *cls)
  * Set ats_property to 0 to find all pgs
  */
 static struct PropertyGenerator *
-find_prop_gen(unsigned int peer, unsigned int address,
-              uint32_t ats_property)
+find_prop_gen (unsigned int peer, unsigned int address,
+               uint32_t ats_property)
 {
   struct PropertyGenerator *cur;
 
   for (cur = prop_gen_head; NULL != cur; cur = cur->next)
     if ((cur->peer == peer) && (cur->address_id == address))
-      {
-        if ((cur->ats_property == ats_property) || (0 == ats_property))
-          return cur;
-      }
+    {
+      if ((cur->ats_property == ats_property) || (0 == ats_property))
+        return cur;
+    }
   return NULL;
 }
 
 void
-GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg)
+GNUNET_ATS_solver_generate_property_stop (struct PropertyGenerator *pg)
 {
-  GNUNET_CONTAINER_DLL_remove(prop_gen_head, prop_gen_tail, pg);
+  GNUNET_CONTAINER_DLL_remove (prop_gen_head, prop_gen_tail, pg);
 
   if (NULL != pg->set_task)
-    {
-      GNUNET_SCHEDULER_cancel(pg->set_task);
-      pg->set_task = NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Removing old up preference generator peer [%u] address [%u] `%s'\n",
-             pg->peer, pg->address_id,
-             GNUNET_ATS_print_property_type(pg->ats_property));
+  {
+    GNUNET_SCHEDULER_cancel (pg->set_task);
+    pg->set_task = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Removing old up preference generator peer [%u] address [%u] `%s'\n",
+              pg->peer, pg->address_id,
+              GNUNET_ATS_print_property_type (pg->ats_property));
 
-  GNUNET_free(pg);
+  GNUNET_free (pg);
 }
 
 
@@ -718,21 +737,22 @@ GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg)
  * @return the property generator
  */
 struct PropertyGenerator *
-GNUNET_ATS_solver_generate_property_start(unsigned int peer,
-                                          unsigned int address_id,
-                                          struct TestPeer *test_peer,
-                                          struct TestAddress *test_address,
-                                          enum GeneratorType type,
-                                          long int base_value,
-                                          long int value_rate,
-                                          struct GNUNET_TIME_Relative period,
-                                          struct GNUNET_TIME_Relative frequency,
-                                          uint32_t ats_property)
+GNUNET_ATS_solver_generate_property_start (unsigned int peer,
+                                           unsigned int address_id,
+                                           struct TestPeer *test_peer,
+                                           struct TestAddress *test_address,
+                                           enum GeneratorType type,
+                                           long int base_value,
+                                           long int value_rate,
+                                           struct GNUNET_TIME_Relative period,
+                                           struct GNUNET_TIME_Relative
+                                           frequency,
+                                           uint32_t ats_property)
 {
   struct PropertyGenerator *pg;
 
-  pg = GNUNET_new(struct PropertyGenerator);
-  GNUNET_CONTAINER_DLL_insert(prop_gen_head, prop_gen_tail, pg);
+  pg = GNUNET_new (struct PropertyGenerator);
+  GNUNET_CONTAINER_DLL_insert (prop_gen_head, prop_gen_tail, pg);
   pg->type = type;
   pg->peer = peer;
   pg->test_address = test_address;
@@ -743,51 +763,51 @@ GNUNET_ATS_solver_generate_property_start(unsigned int peer,
   pg->max_value = value_rate;
   pg->duration_period = period;
   pg->frequency = frequency;
-  pg->time_start = GNUNET_TIME_absolute_get();
+  pg->time_start = GNUNET_TIME_absolute_get ();
 
   switch (type)
-    {
-    case GNUNET_ATS_TEST_TG_CONSTANT:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Setting up %s property generator peer [%u] address [%u] `%s'" \
-                 "max %u Bips\n",
-                 print_generator_type(type), pg->peer, pg->address_id,
-                 GNUNET_ATS_print_property_type(ats_property),
-                 base_value);
-      break;
-
-    case GNUNET_ATS_TEST_TG_LINEAR:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Setting up %s property generator peer [%u] address [%u] `%s' " \
-                 "min %u Bips max %u Bips\n",
-                 print_generator_type(type), pg->peer, pg->address_id,
-                 GNUNET_ATS_print_property_type(ats_property),
-                 base_value, value_rate);
-      break;
-
-    case GNUNET_ATS_TEST_TG_SINUS:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Setting up %s property generator peer [%u] address [%u] `%s' " \
-                 "baserate %u Bips, amplitude %u Bps\n",
-                 print_generator_type(type), pg->peer, pg->address_id,
-                 GNUNET_ATS_print_property_type(ats_property),
-                 base_value, value_rate);
-      break;
-
-    case GNUNET_ATS_TEST_TG_RANDOM:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Setting up %s property generator peer [%u] address [%u] `%s' " \
-                 "min %u Bips max %u Bps\n",
-                 print_generator_type(type), pg->peer, pg->address_id,
-                 GNUNET_ATS_print_property_type(ats_property),
-                 base_value, value_rate);
-      break;
-
-    default:
-      break;
-    }
-
-  pg->set_task = GNUNET_SCHEDULER_add_now(&set_prop_task, pg);
+  {
+  case GNUNET_ATS_TEST_TG_CONSTANT:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Setting up %s property generator peer [%u] address [%u] `%s'" \
+                "max %u Bips\n",
+                print_generator_type (type), pg->peer, pg->address_id,
+                GNUNET_ATS_print_property_type (ats_property),
+                base_value);
+    break;
+
+  case GNUNET_ATS_TEST_TG_LINEAR:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Setting up %s property generator peer [%u] address [%u] `%s' " \
+                "min %u Bips max %u Bips\n",
+                print_generator_type (type), pg->peer, pg->address_id,
+                GNUNET_ATS_print_property_type (ats_property),
+                base_value, value_rate);
+    break;
+
+  case GNUNET_ATS_TEST_TG_SINUS:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Setting up %s property generator peer [%u] address [%u] `%s' " \
+                "baserate %u Bips, amplitude %u Bps\n",
+                print_generator_type (type), pg->peer, pg->address_id,
+                GNUNET_ATS_print_property_type (ats_property),
+                base_value, value_rate);
+    break;
+
+  case GNUNET_ATS_TEST_TG_RANDOM:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Setting up %s property generator peer [%u] address [%u] `%s' " \
+                "min %u Bips max %u Bps\n",
+                print_generator_type (type), pg->peer, pg->address_id,
+                GNUNET_ATS_print_property_type (ats_property),
+                base_value, value_rate);
+    break;
+
+  default:
+    break;
+  }
+
+  pg->set_task = GNUNET_SCHEDULER_add_now (&set_prop_task, pg);
   return pg;
 }
 
@@ -796,17 +816,17 @@ GNUNET_ATS_solver_generate_property_start(unsigned int peer,
  * Stop all preferences generators
  */
 void
-GNUNET_ATS_solver_generate_property_stop_all()
+GNUNET_ATS_solver_generate_property_stop_all ()
 {
   struct PropertyGenerator *cur;
   struct PropertyGenerator *next;
 
   next = prop_gen_head;
   for (cur = next; NULL != cur; cur = next)
-    {
-      next = cur->next;
-      GNUNET_ATS_solver_generate_property_stop(cur);
-    }
+  {
+    next = cur->next;
+    GNUNET_ATS_solver_generate_property_stop (cur);
+  }
 }
 
 
@@ -818,7 +838,7 @@ static struct PreferenceGenerator *pref_gen_tail;
 
 
 static double
-get_preference(struct PreferenceGenerator *pg)
+get_preference (struct PreferenceGenerator *pg)
 {
   struct GNUNET_TIME_Relative time_delta;
   double delta_value;
@@ -826,62 +846,66 @@ get_preference(struct PreferenceGenerator *pg)
 
   /* Calculate the current preference value */
   switch (pg->type)
-    {
-    case GNUNET_ATS_TEST_TG_CONSTANT:
-      pref_value = pg->base_value;
-      break;
-
-    case GNUNET_ATS_TEST_TG_LINEAR:
-      time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start);
-      /* Calculate point of time in the current period */
-      time_delta.rel_value_us = time_delta.rel_value_us %
-                                pg->duration_period.rel_value_us;
-      delta_value = ((double)time_delta.rel_value_us /
-                     pg->duration_period.rel_value_us) * (pg->max_value - pg->base_value);
-      if ((pg->max_value < pg->base_value) &&
-          ((pg->max_value - pg->base_value) > pg->base_value))
-        {
-          /* This will cause an underflow */
-          GNUNET_break(0);
-        }
-      pref_value = pg->base_value + delta_value;
-      break;
-
-    case GNUNET_ATS_TEST_TG_RANDOM:
-      delta_value = (double)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                                     10000 * (pg->max_value - pg->base_value)) / 10000;
-      pref_value = pg->base_value + delta_value;
-      break;
-
-    case GNUNET_ATS_TEST_TG_SINUS:
-      time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start);
-      /* Calculate point of time in the current period */
-      time_delta.rel_value_us = time_delta.rel_value_us %
-                                pg->duration_period.rel_value_us;
-      if ((pg->max_value - pg->base_value) > pg->base_value)
-        {
-          /* This will cause an underflow for second half of sinus period,
-           * will be detected in general when experiments are loaded */
-          GNUNET_break(0);
-        }
-      delta_value = (pg->max_value - pg->base_value) *
-                    sin((2 * M_PI) / ((double)pg->duration_period.rel_value_us) *
-                        time_delta.rel_value_us);
-      pref_value = pg->base_value + delta_value;
-      break;
-
-    default:
-      pref_value = 0.0;
-      break;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Current preference value is %f\n",
-             pref_value);
+  {
+  case GNUNET_ATS_TEST_TG_CONSTANT:
+    pref_value = pg->base_value;
+    break;
+
+  case GNUNET_ATS_TEST_TG_LINEAR:
+    time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
+    /* Calculate point of time in the current period */
+    time_delta.rel_value_us = time_delta.rel_value_us
+                              % pg->duration_period.rel_value_us;
+    delta_value = ((double) time_delta.rel_value_us
+                   / pg->duration_period.rel_value_us) * (pg->max_value
+                                                          - pg->base_value);
+    if ((pg->max_value < pg->base_value) &&
+        ((pg->max_value - pg->base_value) > pg->base_value))
+    {
+      /* This will cause an underflow */
+      GNUNET_break (0);
+    }
+    pref_value = pg->base_value + delta_value;
+    break;
+
+  case GNUNET_ATS_TEST_TG_RANDOM:
+    delta_value = (double) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                     10000 * (pg->max_value
+                                                              - pg->base_value))
+                  / 10000;
+    pref_value = pg->base_value + delta_value;
+    break;
+
+  case GNUNET_ATS_TEST_TG_SINUS:
+    time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
+    /* Calculate point of time in the current period */
+    time_delta.rel_value_us = time_delta.rel_value_us
+                              % pg->duration_period.rel_value_us;
+    if ((pg->max_value - pg->base_value) > pg->base_value)
+    {
+      /* This will cause an underflow for second half of sinus period,
+       * will be detected in general when experiments are loaded */
+      GNUNET_break (0);
+    }
+    delta_value = (pg->max_value - pg->base_value)
+                  * sin ((2 * M_PI)
+                         / ((double) pg->duration_period.rel_value_us)
+                         * time_delta.rel_value_us);
+    pref_value = pg->base_value + delta_value;
+    break;
+
+  default:
+    pref_value = 0.0;
+    break;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Current preference value is %f\n",
+              pref_value);
   return pref_value;
 }
 
 
 static void
-set_feedback_task(void *cls)
+set_feedback_task (void *cls)
 {
   struct PreferenceGenerator *pg = cls;
   struct TestPeer *p;
@@ -894,70 +918,75 @@ set_feedback_task(void *cls)
 
   pg->feedback_task = NULL;
 
-  if (NULL == (p = find_peer_by_id(pg->peer)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting feedback for unknown peer %u\n", pg->peer);
-      return;
-    }
+  if (NULL == (p = find_peer_by_id (pg->peer)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting feedback for unknown peer %u\n", pg->peer);
+    return;
+  }
 
   switch (pg->kind)
-    {
-    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
-      dur = GNUNET_TIME_absolute_get_duration(pg->feedback_last_bw_update);
-      bw_acc_in = dur.rel_value_us * pg->last_assigned_bw_in + pg->feedback_bw_in_acc;
-      pg->feedback_bw_in_acc = 0;
-
-      bw_acc_out = dur.rel_value_us * pg->last_assigned_bw_out + pg->feedback_bw_out_acc;
-      p_new = get_preference(pg);
-      feedback = (p_new / pg->pref_bw_old) * (bw_acc_in + bw_acc_out) /
-                 (2 * GNUNET_TIME_absolute_get_duration(pg->feedback_last).rel_value_us);
-
-      break;
-
-    case GNUNET_ATS_PREFERENCE_LATENCY:
-      dur = GNUNET_TIME_absolute_get_duration(pg->feedback_last_delay_update);
-      delay_acc_in = dur.rel_value_us * pg->last_delay_value + pg->feedback_delay_acc;
-      pg->feedback_delay_acc = 0;
-
-      p_new = get_preference(pg);
-      feedback = (p_new / pg->pref_latency_old) * (delay_acc_in) /
-                 (GNUNET_TIME_absolute_get_duration(pg->feedback_last).rel_value_us);
-
-      break;
-
-    default:
-      GNUNET_break(0);
-      feedback = 0.0;
-      break;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Giving feedback for peer [%u] for client %p pref %s of %.3f\n",
-             pg->peer, NULL + (pg->client_id),
-             GNUNET_ATS_print_preference_type(pg->kind),
-             feedback);
-
-  sh->sf->s_feedback(sh->sf->cls, NULL + (pg->client_id), &p->peer_id,
-                     pg->feedback_frequency, pg->kind, feedback);
-  pg->feedback_last = GNUNET_TIME_absolute_get();
+  {
+  case GNUNET_ATS_PREFERENCE_BANDWIDTH:
+    dur = GNUNET_TIME_absolute_get_duration (pg->feedback_last_bw_update);
+    bw_acc_in = dur.rel_value_us * pg->last_assigned_bw_in
+                + pg->feedback_bw_in_acc;
+    pg->feedback_bw_in_acc = 0;
+
+    bw_acc_out = dur.rel_value_us * pg->last_assigned_bw_out
+                 + pg->feedback_bw_out_acc;
+    p_new = get_preference (pg);
+    feedback = (p_new / pg->pref_bw_old) * (bw_acc_in + bw_acc_out)
+               / (2 * GNUNET_TIME_absolute_get_duration (
+                    pg->feedback_last).rel_value_us);
+
+    break;
+
+  case GNUNET_ATS_PREFERENCE_LATENCY:
+    dur = GNUNET_TIME_absolute_get_duration (pg->feedback_last_delay_update);
+    delay_acc_in = dur.rel_value_us * pg->last_delay_value
+                   + pg->feedback_delay_acc;
+    pg->feedback_delay_acc = 0;
+
+    p_new = get_preference (pg);
+    feedback = (p_new / pg->pref_latency_old) * (delay_acc_in)
+               / (GNUNET_TIME_absolute_get_duration (
+                    pg->feedback_last).rel_value_us);
+
+    break;
+
+  default:
+    GNUNET_break (0);
+    feedback = 0.0;
+    break;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Giving feedback for peer [%u] for client %p pref %s of %.3f\n",
+              pg->peer, NULL + (pg->client_id),
+              GNUNET_ATS_print_preference_type (pg->kind),
+              feedback);
+
+  sh->sf->s_feedback (sh->sf->cls, NULL + (pg->client_id), &p->peer_id,
+                      pg->feedback_frequency, pg->kind, feedback);
+  pg->feedback_last = GNUNET_TIME_absolute_get ();
 
 
   pg->feedback_bw_out_acc = 0;
   pg->feedback_bw_in_acc = 0;
-  pg->feedback_last_bw_update = GNUNET_TIME_absolute_get();
+  pg->feedback_last_bw_update = GNUNET_TIME_absolute_get ();
 
   pg->feedback_delay_acc = 0;
-  pg->feedback_last_delay_update = GNUNET_TIME_absolute_get();
+  pg->feedback_last_delay_update = GNUNET_TIME_absolute_get ();
 
 
-  pg->feedback_task = GNUNET_SCHEDULER_add_delayed(pg->feedback_frequency,
-                                                   &set_feedback_task, pg);
+  pg->feedback_task = GNUNET_SCHEDULER_add_delayed (pg->feedback_frequency,
+                                                    &set_feedback_task, pg);
 }
 
 
 static void
-set_pref_task(void *cls)
+set_pref_task (void *cls)
 {
   struct PreferenceGenerator *pg = cls;
   struct TestPeer *p;
@@ -965,94 +994,94 @@ set_pref_task(void *cls)
 
   pg->set_task = NULL;
 
-  if (NULL == (p = find_peer_by_id(pg->peer)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting preference for unknown peer %u\n", pg->peer);
-      return;
-    }
+  if (NULL == (p = find_peer_by_id (pg->peer)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting preference for unknown peer %u\n", pg->peer);
+    return;
+  }
 
-  pref_value = get_preference(pg);
+  pref_value = get_preference (pg);
   switch (pg->kind)
-    {
-    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
-      pg->pref_bw_old = pref_value;
-      break;
+  {
+  case GNUNET_ATS_PREFERENCE_BANDWIDTH:
+    pg->pref_bw_old = pref_value;
+    break;
 
-    case GNUNET_ATS_PREFERENCE_LATENCY:
-      pg->pref_latency_old = pref_value;
-      break;
+  case GNUNET_ATS_PREFERENCE_LATENCY:
+    pg->pref_latency_old = pref_value;
+    break;
 
-    default:
-      break;
-    }
+  default:
+    break;
+  }
 
   p->pref_abs[pg->kind] = pref_value;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Setting preference for peer [%u] for client %p pref %s to %f\n",
-             pg->peer, NULL + (pg->client_id),
-             GNUNET_ATS_print_preference_type(pg->kind), pref_value);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Setting preference for peer [%u] for client %p pref %s to %f\n",
+              pg->peer, NULL + (pg->client_id),
+              GNUNET_ATS_print_preference_type (pg->kind), pref_value);
 
   if (GNUNET_YES == opt_disable_normalization)
-    {
-      p->pref_abs[pg->kind] = pref_value;
-      p->pref_norm[pg->kind] = pref_value;
-      sh->sf->s_pref(sh->sf->cls, &p->peer_id, pg->kind, pref_value);
-    }
+  {
+    p->pref_abs[pg->kind] = pref_value;
+    p->pref_norm[pg->kind] = pref_value;
+    sh->sf->s_pref (sh->sf->cls, &p->peer_id, pg->kind, pref_value);
+  }
   else
-    update_preference(NULL + (pg->client_id),
-                      &p->peer_id,
-                      pg->kind,
-                      pref_value);
+    update_preference (NULL + (pg->client_id),
+                       &p->peer_id,
+                       pg->kind,
+                       pref_value);
 
-  pg->set_task = GNUNET_SCHEDULER_add_delayed(pg->frequency,
-                                              &set_pref_task,
-                                              pg);
+  pg->set_task = GNUNET_SCHEDULER_add_delayed (pg->frequency,
+                                               &set_pref_task,
+                                               pg);
 }
 
 
 static struct PreferenceGenerator *
-find_pref_gen(unsigned int peer, enum GNUNET_ATS_PreferenceKind kind)
+find_pref_gen (unsigned int peer, enum GNUNET_ATS_PreferenceKind kind)
 {
   struct PreferenceGenerator *cur;
 
   for (cur = pref_gen_head; NULL != cur; cur = cur->next)
     if (cur->peer == peer)
-      {
-        if ((cur->kind == kind) || (GNUNET_ATS_PREFERENCE_END == kind))
-          return cur;
-      }
+    {
+      if ((cur->kind == kind) || (GNUNET_ATS_PREFERENCE_END == kind))
+        return cur;
+    }
   return NULL;
 }
 
 void
-GNUNET_ATS_solver_generate_preferences_stop(struct PreferenceGenerator *pg)
+GNUNET_ATS_solver_generate_preferences_stop (struct PreferenceGenerator *pg)
 {
-  GNUNET_CONTAINER_DLL_remove(pref_gen_head, pref_gen_tail, pg);
+  GNUNET_CONTAINER_DLL_remove (pref_gen_head, pref_gen_tail, pg);
 
   if (NULL != pg->feedback_task)
-    {
-      GNUNET_SCHEDULER_cancel(pg->feedback_task);
-      pg->feedback_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pg->feedback_task);
+    pg->feedback_task = NULL;
+  }
 
   if (NULL != pg->set_task)
-    {
-      GNUNET_SCHEDULER_cancel(pg->set_task);
-      pg->set_task = NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Removing old up preference generator peer [%u] `%s'\n",
-             pg->peer, GNUNET_ATS_print_preference_type(pg->kind));
+  {
+    GNUNET_SCHEDULER_cancel (pg->set_task);
+    pg->set_task = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Removing old up preference generator peer [%u] `%s'\n",
+              pg->peer, GNUNET_ATS_print_preference_type (pg->kind));
 
-  GNUNET_free(pg);
+  GNUNET_free (pg);
 }
 
 
 static struct TestAddress*
-find_active_address(struct TestPeer *p)
+find_active_address (struct TestPeer *p)
 {
   struct TestAddress *cur;
 
@@ -1080,30 +1109,34 @@ find_active_address(struct TestPeer *p)
  * @return the preference generator
  */
 struct PreferenceGenerator *
-GNUNET_ATS_solver_generate_preferences_start(unsigned int peer,
-                                             unsigned int address_id,
-                                             unsigned int client_id,
-                                             enum GeneratorType type,
-                                             long int base_value,
-                                             long int value_rate,
-                                             struct GNUNET_TIME_Relative period,
-                                             struct GNUNET_TIME_Relative frequency,
-                                             enum GNUNET_ATS_PreferenceKind kind,
-                                             struct GNUNET_TIME_Relative feedback_frequency)
+GNUNET_ATS_solver_generate_preferences_start (unsigned int peer,
+                                              unsigned int address_id,
+                                              unsigned int client_id,
+                                              enum GeneratorType type,
+                                              long int base_value,
+                                              long int value_rate,
+                                              struct GNUNET_TIME_Relative
+                                              period,
+                                              struct GNUNET_TIME_Relative
+                                              frequency,
+                                              enum GNUNET_ATS_PreferenceKind
+                                              kind,
+                                              struct GNUNET_TIME_Relative
+                                              feedback_frequency)
 {
   struct PreferenceGenerator *pg;
   struct TestPeer *p;
 
-  if (NULL == (p = find_peer_by_id(peer)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Starting preference for unknown peer %u\n", peer);
-      return NULL;
-    }
-
-  pg = GNUNET_new(struct PreferenceGenerator);
-  GNUNET_CONTAINER_DLL_insert(pref_gen_head, pref_gen_tail, pg);
+  if (NULL == (p = find_peer_by_id (peer)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Starting preference for unknown peer %u\n", peer);
+    return NULL;
+  }
+
+  pg = GNUNET_new (struct PreferenceGenerator);
+  GNUNET_CONTAINER_DLL_insert (pref_gen_head, pref_gen_tail, pg);
   pg->type = type;
   pg->peer = peer;
   pg->client_id = client_id;
@@ -1112,62 +1145,66 @@ GNUNET_ATS_solver_generate_preferences_start(unsigned int peer,
   pg->max_value = value_rate;
   pg->duration_period = period;
   pg->frequency = frequency;
-  pg->time_start = GNUNET_TIME_absolute_get();
+  pg->time_start = GNUNET_TIME_absolute_get ();
   pg->feedback_frequency = feedback_frequency;
 
   switch (type)
-    {
-    case GNUNET_ATS_TEST_TG_CONSTANT:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting up %s preference generator peer [%u] `%s' max %u Bips\n",
-                 print_generator_type(type), pg->peer,
-                 GNUNET_ATS_print_preference_type(kind),
-                 base_value);
-      break;
-
-    case GNUNET_ATS_TEST_TG_LINEAR:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bips\n",
-                 print_generator_type(type), pg->peer, GNUNET_ATS_print_preference_type(kind),
-                 base_value, value_rate);
-      break;
-
-    case GNUNET_ATS_TEST_TG_SINUS:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting up %s preference generator peer [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
-                 print_generator_type(type), pg->peer, GNUNET_ATS_print_preference_type(kind),
-                 base_value, value_rate);
-      break;
-
-    case GNUNET_ATS_TEST_TG_RANDOM:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bps\n",
-                 print_generator_type(type), pg->peer, GNUNET_ATS_print_preference_type(kind),
-                 base_value, value_rate);
-      break;
-
-    default:
-      break;
-    }
-
-  pg->set_task = GNUNET_SCHEDULER_add_now(&set_pref_task, pg);
-  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != feedback_frequency.rel_value_us)
-    {
-      struct TestAddress * addr = find_active_address(p);
-
-      pg->last_assigned_bw_in = p->assigned_bw_in;
-      pg->last_assigned_bw_out = p->assigned_bw_out;
-      pg->feedback_bw_in_acc = 0;
-      pg->feedback_bw_out_acc = 0;
-      pg->last_delay_value = addr->prop_norm[GNUNET_ATS_QUALITY_NET_DELAY];
-      pg->feedback_delay_acc = 0;
-
-      pg->feedback_last_bw_update = GNUNET_TIME_absolute_get();
-      pg->feedback_last_delay_update = GNUNET_TIME_absolute_get();
-      pg->feedback_last = GNUNET_TIME_absolute_get();
-      pg->feedback_task = GNUNET_SCHEDULER_add_delayed(feedback_frequency,
-                                                       &set_feedback_task, pg);
-    }
+  {
+  case GNUNET_ATS_TEST_TG_CONSTANT:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting up %s preference generator peer [%u] `%s' max %u Bips\n",
+                print_generator_type (type), pg->peer,
+                GNUNET_ATS_print_preference_type (kind),
+                base_value);
+    break;
+
+  case GNUNET_ATS_TEST_TG_LINEAR:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bips\n",
+                print_generator_type (type), pg->peer,
+                GNUNET_ATS_print_preference_type (kind),
+                base_value, value_rate);
+    break;
+
+  case GNUNET_ATS_TEST_TG_SINUS:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting up %s preference generator peer [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
+                print_generator_type (type), pg->peer,
+                GNUNET_ATS_print_preference_type (kind),
+                base_value, value_rate);
+    break;
+
+  case GNUNET_ATS_TEST_TG_RANDOM:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bps\n",
+                print_generator_type (type), pg->peer,
+                GNUNET_ATS_print_preference_type (kind),
+                base_value, value_rate);
+    break;
+
+  default:
+    break;
+  }
+
+  pg->set_task = GNUNET_SCHEDULER_add_now (&set_pref_task, pg);
+  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
+      feedback_frequency.rel_value_us)
+  {
+    struct TestAddress *addr = find_active_address (p);
+
+    pg->last_assigned_bw_in = p->assigned_bw_in;
+    pg->last_assigned_bw_out = p->assigned_bw_out;
+    pg->feedback_bw_in_acc = 0;
+    pg->feedback_bw_out_acc = 0;
+    pg->last_delay_value = addr->prop_norm[GNUNET_ATS_QUALITY_NET_DELAY];
+    pg->feedback_delay_acc = 0;
+
+    pg->feedback_last_bw_update = GNUNET_TIME_absolute_get ();
+    pg->feedback_last_delay_update = GNUNET_TIME_absolute_get ();
+    pg->feedback_last = GNUNET_TIME_absolute_get ();
+    pg->feedback_task = GNUNET_SCHEDULER_add_delayed (feedback_frequency,
+                                                      &set_feedback_task, pg);
+  }
 
   return pg;
 }
@@ -1178,17 +1215,17 @@ GNUNET_ATS_solver_generate_preferences_start(unsigned int peer,
  * Stop all preferences generators
  */
 void
-GNUNET_ATS_solver_generate_preferences_stop_all()
+GNUNET_ATS_solver_generate_preferences_stop_all ()
 {
   struct PreferenceGenerator *cur;
   struct PreferenceGenerator *next;
 
   next = pref_gen_head;
   for (cur = next; NULL != cur; cur = next)
-    {
-      next = cur->next;
-      GNUNET_ATS_solver_generate_preferences_stop(cur);
-    }
+  {
+    next = cur->next;
+    GNUNET_ATS_solver_generate_preferences_stop (cur);
+  }
 }
 
 
@@ -1197,47 +1234,47 @@ GNUNET_ATS_solver_generate_preferences_stop_all()
  * Experiments
  */
 static const char *
-print_op(enum OperationType op)
+print_op (enum OperationType op)
 {
   switch (op)
-    {
-    case SOLVER_OP_ADD_ADDRESS:
-      return "ADD_ADDRESS";
+  {
+  case SOLVER_OP_ADD_ADDRESS:
+    return "ADD_ADDRESS";
 
-    case SOLVER_OP_DEL_ADDRESS:
-      return "DEL_ADDRESS";
+  case SOLVER_OP_DEL_ADDRESS:
+    return "DEL_ADDRESS";
 
-    case SOLVER_OP_START_SET_PREFERENCE:
-      return "START_SET_PREFERENCE";
+  case SOLVER_OP_START_SET_PREFERENCE:
+    return "START_SET_PREFERENCE";
 
-    case SOLVER_OP_STOP_SET_PREFERENCE:
-      return "STOP_STOP_PREFERENCE";
+  case SOLVER_OP_STOP_SET_PREFERENCE:
+    return "STOP_STOP_PREFERENCE";
 
-    case SOLVER_OP_START_SET_PROPERTY:
-      return "START_SET_PROPERTY";
+  case SOLVER_OP_START_SET_PROPERTY:
+    return "START_SET_PROPERTY";
 
-    case SOLVER_OP_STOP_SET_PROPERTY:
-      return "STOP_SET_PROPERTY";
+  case SOLVER_OP_STOP_SET_PROPERTY:
+    return "STOP_SET_PROPERTY";
 
-    case SOLVER_OP_START_REQUEST:
-      return "START_REQUEST";
+  case SOLVER_OP_START_REQUEST:
+    return "START_REQUEST";
 
-    case SOLVER_OP_STOP_REQUEST:
-      return "STOP_REQUEST";
+  case SOLVER_OP_STOP_REQUEST:
+    return "STOP_REQUEST";
 
-    default:
-      break;
-    }
+  default:
+    break;
+  }
   return "";
 }
 
 
 static struct Experiment *
-create_experiment()
+create_experiment ()
 {
   struct Experiment *e;
 
-  e = GNUNET_new(struct Experiment);
+  e = GNUNET_new (struct Experiment);
   e->name = NULL;
   e->start = NULL;
   e->total_duration = GNUNET_TIME_UNIT_ZERO;
@@ -1246,7 +1283,7 @@ create_experiment()
 
 
 static void
-free_experiment(struct Experiment *e)
+free_experiment (struct Experiment *e)
 {
   struct Episode *cur;
   struct Episode *next;
@@ -1255,771 +1292,820 @@ free_experiment(struct Experiment *e)
 
   next = e->start;
   for (cur = next; NULL != cur; cur = next)
-    {
-      next = cur->next;
+  {
+    next = cur->next;
 
-      next_o = cur->head;
-      for (cur_o = next_o; NULL != cur_o; cur_o = next_o)
-        {
-          next_o = cur_o->next;
-          GNUNET_free_non_null(cur_o->address);
-          GNUNET_free_non_null(cur_o->plugin);
-          GNUNET_free(cur_o);
-        }
-      GNUNET_free(cur);
+    next_o = cur->head;
+    for (cur_o = next_o; NULL != cur_o; cur_o = next_o)
+    {
+      next_o = cur_o->next;
+      GNUNET_free_non_null (cur_o->address);
+      GNUNET_free_non_null (cur_o->plugin);
+      GNUNET_free (cur_o);
     }
+    GNUNET_free (cur);
+  }
 
-  GNUNET_free_non_null(e->name);
-  GNUNET_free_non_null(e->log_prefix);
-  GNUNET_free_non_null(e->log_output_dir);
-  GNUNET_free_non_null(e->cfg_file);
-  GNUNET_free(e);
+  GNUNET_free_non_null (e->name);
+  GNUNET_free_non_null (e->log_prefix);
+  GNUNET_free_non_null (e->log_output_dir);
+  GNUNET_free_non_null (e->cfg_file);
+  GNUNET_free (e);
 }
 
 
 static int
-load_op_add_address(struct GNUNET_ATS_TEST_Operation *o,
-                    struct Episode *e,
-                    int op_counter,
-                    char *sec_name,
-                    const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_add_address (struct GNUNET_ATS_TEST_Operation *o,
+                     struct Episode *e,
+                     int op_counter,
+                     char *sec_name,
+                     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
   char *op_network;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "ADD_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "ADD_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address pid */
-  GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->address_id))
-    {
-      fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "ADD_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->address_id))
+  {
+    fprintf (stderr,
+             "Missing address-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "ADD_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* plugin */
-  GNUNET_asprintf(&op_name, "op-%u-plugin", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &o->plugin))
-    {
-      fprintf(stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
-              op_counter, "ADD_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-plugin", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &o->plugin))
+  {
+    fprintf (stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
+             op_counter, "ADD_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address  */
-  GNUNET_asprintf(&op_name, "op-%u-address", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &o->address))
-    {
-      fprintf(stderr, "Missing address in operation %u `%s' in episode `%s'\n",
-              op_counter, "ADD_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &o->address))
+  {
+    fprintf (stderr, "Missing address in operation %u `%s' in episode `%s'\n",
+             op_counter, "ADD_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* session */
-  GNUNET_asprintf(&op_name, "op-%u-address-session", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->address_session))
-    {
-      fprintf(stderr, "Missing address-session in operation %u `%s' in episode `%s'\n",
-              op_counter, "ADD_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address-session", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->
+                                                              address_session))
+  {
+    fprintf (stderr,
+             "Missing address-session in operation %u `%s' in episode `%s'\n",
+             op_counter, "ADD_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* network */
-  GNUNET_asprintf(&op_name, "op-%u-address-network", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &op_network))
+  GNUNET_asprintf (&op_name, "op-%u-address-network", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &op_network))
+  {
+    fprintf (stderr,
+             "Missing address-network in operation %u `%s' in episode `%s'\n",
+             op_counter, "ADD_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  else
+  {
+    GNUNET_STRINGS_utf8_toupper (op_network, op_network);
+    if (0 == strcmp (op_network, "UNSPECIFIED"))
     {
-      fprintf(stderr, "Missing address-network in operation %u `%s' in episode `%s'\n",
-              op_counter, "ADD_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
+      o->address_network = GNUNET_NT_UNSPECIFIED;
     }
-  else
+    else if (0 == strcmp (op_network, "LOOPBACK"))
     {
-      GNUNET_STRINGS_utf8_toupper(op_network, op_network);
-      if (0 == strcmp(op_network, "UNSPECIFIED"))
-        {
-          o->address_network = GNUNET_NT_UNSPECIFIED;
-        }
-      else if (0 == strcmp(op_network, "LOOPBACK"))
-        {
-          o->address_network = GNUNET_NT_LOOPBACK;
-        }
-      else if (0 == strcmp(op_network, "LAN"))
-        {
-          o->address_network = GNUNET_NT_LAN;
-        }
-      else if (0 == strcmp(op_network, "WAN"))
-        {
-          o->address_network = GNUNET_NT_WAN;
-        }
-      else if (0 == strcmp(op_network, "WLAN"))
-        {
-          o->address_network = GNUNET_NT_WLAN;
-        }
-      else if (0 == strcmp(op_network, "BT"))
-        {
-          o->address_network = GNUNET_NT_BT;
-        }
-      else
-        {
-          fprintf(stderr, "Invalid address-network in operation %u `%s' in episode `%s': `%s'\n",
-                  op_counter, "ADD_ADDRESS", op_name, op_network);
-          GNUNET_free(op_network);
-          GNUNET_free(op_name);
-          return GNUNET_SYSERR;
-        }
+      o->address_network = GNUNET_NT_LOOPBACK;
+    }
+    else if (0 == strcmp (op_network, "LAN"))
+    {
+      o->address_network = GNUNET_NT_LAN;
+    }
+    else if (0 == strcmp (op_network, "WAN"))
+    {
+      o->address_network = GNUNET_NT_WAN;
+    }
+    else if (0 == strcmp (op_network, "WLAN"))
+    {
+      o->address_network = GNUNET_NT_WLAN;
+    }
+    else if (0 == strcmp (op_network, "BT"))
+    {
+      o->address_network = GNUNET_NT_BT;
+    }
+    else
+    {
+      fprintf (stderr,
+               "Invalid address-network in operation %u `%s' in episode `%s': `%s'\n",
+               op_counter, "ADD_ADDRESS", op_name, op_network);
+      GNUNET_free (op_network);
+      GNUNET_free (op_name);
+      return GNUNET_SYSERR;
     }
-  GNUNET_free(op_network);
-  GNUNET_free(op_name);
+  }
+  GNUNET_free (op_network);
+  GNUNET_free (op_name);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
-             "ADD_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
+              "ADD_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
 
   return GNUNET_OK;
 }
 
 
 static int
-load_op_del_address(struct GNUNET_ATS_TEST_Operation *o,
-                    struct Episode *e,
-                    int op_counter,
-                    char *sec_name,
-                    const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_del_address (struct GNUNET_ATS_TEST_Operation *o,
+                     struct Episode *e,
+                     int op_counter,
+                     char *sec_name,
+                     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
 
-  //char *op_network;
+  // char *op_network;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "DEL_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "DEL_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address pid */
-  GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->address_id))
-    {
-      fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "DEL_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->address_id))
+  {
+    fprintf (stderr,
+             "Missing address-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "DEL_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
 #if 0
   /* plugin */
-  GNUNET_asprintf(&op_name, "op-%u-plugin", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &o->plugin))
-    {
-      fprintf(stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
-              op_counter, "DEL_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-plugin", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &o->plugin))
+  {
+    fprintf (stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
+             op_counter, "DEL_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address  */
-  GNUNET_asprintf(&op_name, "op-%u-address", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &o->address))
-    {
-      fprintf(stderr, "Missing address in operation %u `%s' in episode `%s'\n",
-              op_counter, "DEL_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &o->address))
+  {
+    fprintf (stderr, "Missing address in operation %u `%s' in episode `%s'\n",
+             op_counter, "DEL_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* session */
-  GNUNET_asprintf(&op_name, "op-%u-address-session", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->address_session))
-    {
-      fprintf(stderr, "Missing address-session in operation %u `%s' in episode `%s'\n",
-              op_counter, "DEL_ADDRESS", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address-session", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->
+                                                              address_session))
+  {
+    fprintf (stderr,
+             "Missing address-session in operation %u `%s' in episode `%s'\n",
+             op_counter, "DEL_ADDRESS", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 #endif
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
-             "DEL_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
+              "DEL_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
 
   return GNUNET_OK;
 }
 
 
 static enum GNUNET_ATS_Property
-parse_preference_string(const char * str)
+parse_preference_string (const char *str)
 {
   int c = 0;
   char *props[GNUNET_ATS_PreferenceCount] = GNUNET_ATS_PreferenceTypeString;
 
   for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
-    if (0 == strcmp(str, props[c]))
+    if (0 == strcmp (str, props[c]))
       return c;
   return 0;
 }
 
 
 static int
-load_op_start_set_preference(struct GNUNET_ATS_TEST_Operation *o,
-                             struct Episode *e,
-                             int op_counter,
-                             char *sec_name,
-                             const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_start_set_preference (struct GNUNET_ATS_TEST_Operation *o,
+                              struct Episode *e,
+                              int op_counter,
+                              char *sec_name,
+                              const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
   char *type;
   char *pref;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
-              op_counter, "START_SET_PREFERENCE", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
+             op_counter, "START_SET_PREFERENCE", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address pid */
-  GNUNET_asprintf(&op_name, "op-%u-client-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->client_id))
-    {
-      fprintf(stderr, "Missing client-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "START_SET_PREFERENCE", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-client-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->client_id))
+  {
+    fprintf (stderr, "Missing client-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "START_SET_PREFERENCE", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* generator */
-  GNUNET_asprintf(&op_name, "op-%u-gen-type", op_counter);
-  if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                              sec_name, op_name, &type)))
-    {
-      fprintf(stderr, "Missing type in operation %u `%s' in episode `%s'\n",
-              op_counter, "START_SET_PREFERENCE", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
+  GNUNET_asprintf (&op_name, "op-%u-gen-type", op_counter);
+  if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                               sec_name,
+                                                               op_name, &type)))
+  {
+    fprintf (stderr, "Missing type in operation %u `%s' in episode `%s'\n",
+             op_counter, "START_SET_PREFERENCE", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
 
   /* Load arguments for set_rate, start_send, set_preference */
-  if (0 == strcmp(type, "constant"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT;
-    }
-  else if (0 == strcmp(type, "linear"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_LINEAR;
-    }
-  else if (0 == strcmp(type, "sinus"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_SINUS;
-    }
-  else if (0 == strcmp(type, "random"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_RANDOM;
-    }
+  if (0 == strcmp (type, "constant"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT;
+  }
+  else if (0 == strcmp (type, "linear"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_LINEAR;
+  }
+  else if (0 == strcmp (type, "sinus"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_SINUS;
+  }
+  else if (0 == strcmp (type, "random"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_RANDOM;
+  }
   else
-    {
-      fprintf(stderr, "Invalid generator type %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(type);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(type);
-  GNUNET_free(op_name);
+  {
+    fprintf (stderr, "Invalid generator type %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (type);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (type);
+  GNUNET_free (op_name);
 
 
   /* Get base rate */
-  GNUNET_asprintf(&op_name, "op-%u-base-rate", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->base_rate))
-    {
-      fprintf(stderr, "Missing base rate in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-base-rate", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->base_rate))
+  {
+    fprintf (stderr, "Missing base rate in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
 
   /* Get max rate */
-  GNUNET_asprintf(&op_name, "op-%u-max-rate", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->max_rate))
+  GNUNET_asprintf (&op_name, "op-%u-max-rate", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->max_rate))
+  {
+    if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
+        (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) ||
+        (GNUNET_ATS_TEST_TG_SINUS == o->gen_type))
     {
-      if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
-          (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) ||
-          (GNUNET_ATS_TEST_TG_SINUS == o->gen_type))
-        {
-          fprintf(stderr, "Missing max rate in operation %u `%s' in episode %u\n",
-                  op_counter, op_name, e->id);
-          GNUNET_free(op_name);
-          return GNUNET_SYSERR;
-        }
+      fprintf (stderr, "Missing max rate in operation %u `%s' in episode %u\n",
+               op_counter, op_name, e->id);
+      GNUNET_free (op_name);
+      return GNUNET_SYSERR;
     }
-  GNUNET_free(op_name);
+  }
+  GNUNET_free (op_name);
 
   /* Get period */
-  GNUNET_asprintf(&op_name, "op-%u-period", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                           sec_name, op_name, &o->period))
-    {
-      o->period = e->duration;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-period", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                            sec_name, op_name,
+                                                            &o->period))
+  {
+    o->period = e->duration;
+  }
+  GNUNET_free (op_name);
 
   /* Get frequency */
-  GNUNET_asprintf(&op_name, "op-%u-frequency", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                           sec_name, op_name, &o->frequency))
-    {
-      fprintf(stderr, "Missing frequency in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-frequency", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                            sec_name, op_name,
+                                                            &o->frequency))
+  {
+    fprintf (stderr, "Missing frequency in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* Get preference */
-  GNUNET_asprintf(&op_name, "op-%u-pref", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &pref))
-    {
-      fprintf(stderr, "Missing preference in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
+  GNUNET_asprintf (&op_name, "op-%u-pref", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &pref))
+  {
+    fprintf (stderr, "Missing preference in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
 
-  if (0 == (o->pref_type = parse_preference_string(pref)))
-    {
-      fprintf(stderr, "Invalid preference in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      GNUNET_free(pref);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(pref);
-  GNUNET_free(op_name);
+  if (0 == (o->pref_type = parse_preference_string (pref)))
+  {
+    fprintf (stderr, "Invalid preference in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    GNUNET_free (pref);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (pref);
+  GNUNET_free (op_name);
 
   /* Get feedback delay */
-  GNUNET_asprintf(&op_name, "op-%u-feedback_delay", op_counter);
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                       sec_name, op_name, &o->feedback_delay))
-    {
-      fprintf(stderr, "Using feedback delay %llu in operation %u `%s' in episode %u\n",
-              (long long unsigned int)o->feedback_delay.rel_value_us,
-              op_counter, op_name, e->id);
-    }
+  GNUNET_asprintf (&op_name, "op-%u-feedback_delay", op_counter);
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                        sec_name, op_name,
+                                                        &o->feedback_delay))
+  {
+    fprintf (stderr,
+             "Using feedback delay %llu in operation %u `%s' in episode %u\n",
+             (long long unsigned int) o->feedback_delay.rel_value_us,
+             op_counter, op_name, e->id);
+  }
   else
     o->feedback_delay = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_free(op_name);
+  GNUNET_free (op_name);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Found operation %s: [%llu:%llu]: %s = %llu\n",
-             "START_SET_PREFERENCE", o->peer_id, o->address_id,
-             GNUNET_ATS_print_preference_type(o->pref_type), o->base_rate);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Found operation %s: [%llu:%llu]: %s = %llu\n",
+              "START_SET_PREFERENCE", o->peer_id, o->address_id,
+              GNUNET_ATS_print_preference_type (o->pref_type), o->base_rate);
 
   return GNUNET_OK;
 }
 
 
 static int
-load_op_stop_set_preference(struct GNUNET_ATS_TEST_Operation *o,
-                            struct Episode *e,
-                            int op_counter,
-                            char *sec_name,
-                            const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_stop_set_preference (struct GNUNET_ATS_TEST_Operation *o,
+                             struct Episode *e,
+                             int op_counter,
+                             char *sec_name,
+                             const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
   char *pref;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
-              op_counter, "STOP_SET_PREFERENCE", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
+             op_counter, "STOP_SET_PREFERENCE", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address pid */
-  GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->address_id))
-    {
-      fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "STOP_SET_PREFERENCE", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->address_id))
+  {
+    fprintf (stderr,
+             "Missing address-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "STOP_SET_PREFERENCE", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* Get preference */
-  GNUNET_asprintf(&op_name, "op-%u-pref", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &pref))
-    {
-      fprintf(stderr, "Missing preference in operation %u `%s' in episode `%s'\n",
-              op_counter, "STOP_SET_PREFERENCE", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-
-  if (0 == (o->pref_type = parse_preference_string(pref)))
-    {
-      fprintf(stderr, "Invalid preference in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      GNUNET_free(pref);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(pref);
-  GNUNET_free(op_name);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Found operation %s: [%llu:%llu]: %s\n",
-             "STOP_SET_PREFERENCE", o->peer_id, o->address_id,
-             GNUNET_ATS_print_preference_type(o->pref_type));
+  GNUNET_asprintf (&op_name, "op-%u-pref", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &pref))
+  {
+    fprintf (stderr,
+             "Missing preference in operation %u `%s' in episode `%s'\n",
+             op_counter, "STOP_SET_PREFERENCE", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+
+  if (0 == (o->pref_type = parse_preference_string (pref)))
+  {
+    fprintf (stderr, "Invalid preference in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    GNUNET_free (pref);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (pref);
+  GNUNET_free (op_name);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Found operation %s: [%llu:%llu]: %s\n",
+              "STOP_SET_PREFERENCE", o->peer_id, o->address_id,
+              GNUNET_ATS_print_preference_type (o->pref_type));
   return GNUNET_OK;
 }
 
 
 static enum GNUNET_ATS_Property
-parse_property_string(const char *str)
+parse_property_string (const char *str)
 {
   enum GNUNET_ATS_Property c;
 
   for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
-    if (0 == strcmp(str,
-                    GNUNET_ATS_print_property_type(c)))
+    if (0 == strcmp (str,
+                     GNUNET_ATS_print_property_type (c)))
       return c;
   return 0;
 }
 
 
 static int
-load_op_start_set_property(struct GNUNET_ATS_TEST_Operation *o,
-                           struct Episode *e,
-                           int op_counter,
-                           char *sec_name,
-                           const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_start_set_property (struct GNUNET_ATS_TEST_Operation *o,
+                            struct Episode *e,
+                            int op_counter,
+                            char *sec_name,
+                            const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
   char *type;
   char *prop;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
-              op_counter, "START_SET_PROPERTY", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
+             op_counter, "START_SET_PROPERTY", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address pid */
-  GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->address_id))
-    {
-      fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "START_SET_PROPERTY", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->address_id))
+  {
+    fprintf (stderr,
+             "Missing address-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "START_SET_PROPERTY", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* generator */
-  GNUNET_asprintf(&op_name, "op-%u-gen-type", op_counter);
-  if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                              sec_name, op_name, &type)))
-    {
-      fprintf(stderr, "Missing type in operation %u `%s' in episode `%s'\n",
-              op_counter, "START_SET_PROPERTY", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
+  GNUNET_asprintf (&op_name, "op-%u-gen-type", op_counter);
+  if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                               sec_name,
+                                                               op_name, &type)))
+  {
+    fprintf (stderr, "Missing type in operation %u `%s' in episode `%s'\n",
+             op_counter, "START_SET_PROPERTY", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
 
   /* Load arguments for set_rate, start_send, set_preference */
-  if (0 == strcmp(type, "constant"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT;
-    }
-  else if (0 == strcmp(type, "linear"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_LINEAR;
-    }
-  else if (0 == strcmp(type, "sinus"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_SINUS;
-    }
-  else if (0 == strcmp(type, "random"))
-    {
-      o->gen_type = GNUNET_ATS_TEST_TG_RANDOM;
-    }
+  if (0 == strcmp (type, "constant"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT;
+  }
+  else if (0 == strcmp (type, "linear"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_LINEAR;
+  }
+  else if (0 == strcmp (type, "sinus"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_SINUS;
+  }
+  else if (0 == strcmp (type, "random"))
+  {
+    o->gen_type = GNUNET_ATS_TEST_TG_RANDOM;
+  }
   else
-    {
-      fprintf(stderr, "Invalid generator type %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(type);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(type);
-  GNUNET_free(op_name);
+  {
+    fprintf (stderr, "Invalid generator type %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (type);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (type);
+  GNUNET_free (op_name);
 
 
   /* Get base rate */
-  GNUNET_asprintf(&op_name, "op-%u-base-rate", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->base_rate))
-    {
-      fprintf(stderr, "Missing base rate in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-base-rate", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->base_rate))
+  {
+    fprintf (stderr, "Missing base rate in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
 
   /* Get max rate */
-  GNUNET_asprintf(&op_name, "op-%u-max-rate", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->max_rate))
+  GNUNET_asprintf (&op_name, "op-%u-max-rate", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->max_rate))
+  {
+    if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
+        (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) ||
+        (GNUNET_ATS_TEST_TG_SINUS == o->gen_type))
     {
-      if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
-          (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) ||
-          (GNUNET_ATS_TEST_TG_SINUS == o->gen_type))
-        {
-          fprintf(stderr, "Missing max rate in operation %u `%s' in episode %u\n",
-                  op_counter, op_name, e->id);
-          GNUNET_free(op_name);
-          return GNUNET_SYSERR;
-        }
+      fprintf (stderr, "Missing max rate in operation %u `%s' in episode %u\n",
+               op_counter, op_name, e->id);
+      GNUNET_free (op_name);
+      return GNUNET_SYSERR;
     }
-  GNUNET_free(op_name);
+  }
+  GNUNET_free (op_name);
 
   /* Get period */
-  GNUNET_asprintf(&op_name, "op-%u-period", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                           sec_name, op_name, &o->period))
-    {
-      o->period = e->duration;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-period", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                            sec_name, op_name,
+                                                            &o->period))
+  {
+    o->period = e->duration;
+  }
+  GNUNET_free (op_name);
 
   /* Get frequency */
-  GNUNET_asprintf(&op_name, "op-%u-frequency", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                           sec_name, op_name, &o->frequency))
-    {
-      fprintf(stderr, "Missing frequency in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-frequency", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                            sec_name, op_name,
+                                                            &o->frequency))
+  {
+    fprintf (stderr, "Missing frequency in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* Get preference */
-  GNUNET_asprintf(&op_name, "op-%u-property", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &prop))
-    {
-      fprintf(stderr, "Missing property in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      GNUNET_free_non_null(prop);
-      return GNUNET_SYSERR;
-    }
-
-  if (0 == (o->prop_type = parse_property_string(prop)))
-    {
-      fprintf(stderr, "Invalid property in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      GNUNET_free(prop);
-      return GNUNET_SYSERR;
-    }
+  GNUNET_asprintf (&op_name, "op-%u-property", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &prop))
+  {
+    fprintf (stderr, "Missing property in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    GNUNET_free_non_null (prop);
+    return GNUNET_SYSERR;
+  }
+
+  if (0 == (o->prop_type = parse_property_string (prop)))
+  {
+    fprintf (stderr, "Invalid property in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    GNUNET_free (prop);
+    return GNUNET_SYSERR;
+  }
 
-  GNUNET_free(prop);
-  GNUNET_free(op_name);
+  GNUNET_free (prop);
+  GNUNET_free (op_name);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Found operation %s: [%llu:%llu] %s = %llu\n",
-             "START_SET_PROPERTY", o->peer_id, o->address_id,
-             GNUNET_ATS_print_property_type(o->prop_type), o->base_rate);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Found operation %s: [%llu:%llu] %s = %llu\n",
+              "START_SET_PROPERTY", o->peer_id, o->address_id,
+              GNUNET_ATS_print_property_type (o->prop_type), o->base_rate);
 
   return GNUNET_OK;
 }
 
 static int
-load_op_stop_set_property(struct GNUNET_ATS_TEST_Operation *o,
-                          struct Episode *e,
-                          int op_counter,
-                          char *sec_name,
-                          const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_stop_set_property (struct GNUNET_ATS_TEST_Operation *o,
+                           struct Episode *e,
+                           int op_counter,
+                           char *sec_name,
+                           const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
   char *pref;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
-              op_counter, "STOP_SET_PROPERTY", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
+             op_counter, "STOP_SET_PROPERTY", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* address pid */
-  GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->address_id))
-    {
-      fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n",
-              op_counter, "STOP_SET_PROPERTY", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->address_id))
+  {
+    fprintf (stderr,
+             "Missing address-id in operation %u `%s' in episode `%s'\n",
+             op_counter, "STOP_SET_PROPERTY", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
 
   /* Get property */
-  GNUNET_asprintf(&op_name, "op-%u-property", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                             sec_name, op_name, &pref))
-    {
-      fprintf(stderr, "Missing property in operation %u `%s' in episode `%s'\n",
-              op_counter, "STOP_SET_PROPERTY", op_name);
-      GNUNET_free(op_name);
-      GNUNET_free_non_null(pref);
-      return GNUNET_SYSERR;
-    }
-
-  if (0 == (o->prop_type = parse_property_string(pref)))
-    {
-      fprintf(stderr, "Invalid property in operation %u `%s' in episode %u\n",
-              op_counter, op_name, e->id);
-      GNUNET_free(op_name);
-      GNUNET_free_non_null(pref);
-      return GNUNET_SYSERR;
-    }
+  GNUNET_asprintf (&op_name, "op-%u-property", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                              sec_name, op_name,
+                                                              &pref))
+  {
+    fprintf (stderr, "Missing property in operation %u `%s' in episode `%s'\n",
+             op_counter, "STOP_SET_PROPERTY", op_name);
+    GNUNET_free (op_name);
+    GNUNET_free_non_null (pref);
+    return GNUNET_SYSERR;
+  }
+
+  if (0 == (o->prop_type = parse_property_string (pref)))
+  {
+    fprintf (stderr, "Invalid property in operation %u `%s' in episode %u\n",
+             op_counter, op_name, e->id);
+    GNUNET_free (op_name);
+    GNUNET_free_non_null (pref);
+    return GNUNET_SYSERR;
+  }
 
-  GNUNET_free(pref);
-  GNUNET_free(op_name);
+  GNUNET_free (pref);
+  GNUNET_free (op_name);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Found operation %s: [%llu:%llu] %s\n",
-             "STOP_SET_PROPERTY", o->peer_id, o->address_id,
-             GNUNET_ATS_print_property_type(o->prop_type));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Found operation %s: [%llu:%llu] %s\n",
+              "STOP_SET_PROPERTY", o->peer_id, o->address_id,
+              GNUNET_ATS_print_property_type (o->prop_type));
 
   return GNUNET_OK;
 }
 
 
 static int
-load_op_start_request(struct GNUNET_ATS_TEST_Operation *o,
-                      struct Episode *e,
-                      int op_counter,
-                      char *sec_name,
-                      const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_start_request (struct GNUNET_ATS_TEST_Operation *o,
+                       struct Episode *e,
+                       int op_counter,
+                       char *sec_name,
+                       const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
-              op_counter, "START_REQUEST", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
+             op_counter, "START_REQUEST", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
   return GNUNET_OK;
 }
 
 static int
-load_op_stop_request(struct GNUNET_ATS_TEST_Operation *o,
-                     struct Episode *e,
-                     int op_counter,
-                     char *sec_name,
-                     const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_op_stop_request (struct GNUNET_ATS_TEST_Operation *o,
+                      struct Episode *e,
+                      int op_counter,
+                      char *sec_name,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *op_name;
 
   /* peer pid */
-  GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter);
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             sec_name, op_name, &o->peer_id))
-    {
-      fprintf(stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
-              op_counter, "STOP_REQUEST", op_name);
-      GNUNET_free(op_name);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(op_name);
+  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                              sec_name, op_name,
+                                                              &o->peer_id))
+  {
+    fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
+             op_counter, "STOP_REQUEST", op_name);
+    GNUNET_free (op_name);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (op_name);
   return GNUNET_OK;
 }
 
 
 static int
-load_episode(struct Experiment *e, struct Episode *cur,
-             struct GNUNET_CONFIGURATION_Handle *cfg)
+load_episode (struct Experiment *e, struct Episode *cur,
+              struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_ATS_TEST_Operation *o;
   char *sec_name;
@@ -2028,98 +2114,99 @@ load_episode(struct Experiment *e, struct Episode *cur,
   int op_counter = 0;
   int res;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Parsing episode %u\n", cur->id);
-  GNUNET_asprintf(&sec_name, "episode-%u", cur->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Parsing episode %u\n", cur->id);
+  GNUNET_asprintf (&sec_name, "episode-%u", cur->id);
 
   while (1)
+  {
+    /* Load operation */
+    GNUNET_asprintf (&op_name, "op-%u-operation", op_counter);
+    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                                sec_name,
+                                                                op_name, &op))
     {
-      /* Load operation */
-      GNUNET_asprintf(&op_name, "op-%u-operation", op_counter);
-      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                                 sec_name, op_name, &op))
-        {
-          GNUNET_free(op_name);
-          break;
-        }
-      o = GNUNET_new(struct GNUNET_ATS_TEST_Operation);
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "==== Parsing operation %u: `%s'\n",
-                 cur->id, op_name);
+      GNUNET_free (op_name);
+      break;
+    }
+    o = GNUNET_new (struct GNUNET_ATS_TEST_Operation);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "==== Parsing operation %u: `%s'\n",
+                cur->id, op_name);
 
-      /* operations = set_rate, start_send, stop_send, set_preference */
-      if (0 == strcmp(op, "address_add"))
-        {
-          o->type = SOLVER_OP_ADD_ADDRESS;
-          res = load_op_add_address(o, cur,
-                                    op_counter, sec_name, cfg);
-        }
-      else if (0 == strcmp(op, "address_del"))
-        {
-          o->type = SOLVER_OP_DEL_ADDRESS;
-          res = load_op_del_address(o, cur,
-                                    op_counter, sec_name, cfg);
-        }
-      else if (0 == strcmp(op, "start_set_property"))
-        {
-          o->type = SOLVER_OP_START_SET_PROPERTY;
-          res = load_op_start_set_property(o, cur,
-                                           op_counter, sec_name, cfg);
-        }
-      else if (0 == strcmp(op, "stop_set_property"))
-        {
-          o->type = SOLVER_OP_STOP_SET_PROPERTY;
-          res = load_op_stop_set_property(o, cur,
+    /* operations = set_rate, start_send, stop_send, set_preference */
+    if (0 == strcmp (op, "address_add"))
+    {
+      o->type = SOLVER_OP_ADD_ADDRESS;
+      res = load_op_add_address (o, cur,
+                                 op_counter, sec_name, cfg);
+    }
+    else if (0 == strcmp (op, "address_del"))
+    {
+      o->type = SOLVER_OP_DEL_ADDRESS;
+      res = load_op_del_address (o, cur,
+                                 op_counter, sec_name, cfg);
+    }
+    else if (0 == strcmp (op, "start_set_property"))
+    {
+      o->type = SOLVER_OP_START_SET_PROPERTY;
+      res = load_op_start_set_property (o, cur,
+                                        op_counter, sec_name, cfg);
+    }
+    else if (0 == strcmp (op, "stop_set_property"))
+    {
+      o->type = SOLVER_OP_STOP_SET_PROPERTY;
+      res = load_op_stop_set_property (o, cur,
+                                       op_counter, sec_name, cfg);
+    }
+    else if (0 == strcmp (op, "start_set_preference"))
+    {
+      o->type = SOLVER_OP_START_SET_PREFERENCE;
+      res = load_op_start_set_preference (o, cur,
                                           op_counter, sec_name, cfg);
-        }
-      else if (0 == strcmp(op, "start_set_preference"))
-        {
-          o->type = SOLVER_OP_START_SET_PREFERENCE;
-          res = load_op_start_set_preference(o, cur,
-                                             op_counter, sec_name, cfg);
-        }
-      else if (0 == strcmp(op, "stop_set_preference"))
-        {
-          o->type = SOLVER_OP_STOP_SET_PREFERENCE;
-          res = load_op_stop_set_preference(o, cur,
-                                            op_counter, sec_name, cfg);
-        }
-      else if (0 == strcmp(op, "start_request"))
-        {
-          o->type = SOLVER_OP_START_REQUEST;
-          res = load_op_start_request(o, cur,
-                                      op_counter, sec_name, cfg);
-        }
-      else if (0 == strcmp(op, "stop_request"))
-        {
-          o->type = SOLVER_OP_STOP_REQUEST;
-          res = load_op_stop_request(o, cur,
-                                     op_counter, sec_name, cfg);
-        }
-      else
-        {
-          fprintf(stderr, "Invalid operation %u `%s' in episode %u\n",
-                  op_counter, op, cur->id);
-          res = GNUNET_SYSERR;
-        }
-
-      GNUNET_free(op);
-      GNUNET_free(op_name);
+    }
+    else if (0 == strcmp (op, "stop_set_preference"))
+    {
+      o->type = SOLVER_OP_STOP_SET_PREFERENCE;
+      res = load_op_stop_set_preference (o, cur,
+                                         op_counter, sec_name, cfg);
+    }
+    else if (0 == strcmp (op, "start_request"))
+    {
+      o->type = SOLVER_OP_START_REQUEST;
+      res = load_op_start_request (o, cur,
+                                   op_counter, sec_name, cfg);
+    }
+    else if (0 == strcmp (op, "stop_request"))
+    {
+      o->type = SOLVER_OP_STOP_REQUEST;
+      res = load_op_stop_request (o, cur,
+                                  op_counter, sec_name, cfg);
+    }
+    else
+    {
+      fprintf (stderr, "Invalid operation %u `%s' in episode %u\n",
+               op_counter, op, cur->id);
+      res = GNUNET_SYSERR;
+    }
 
-      if (GNUNET_SYSERR == res)
-        {
-          GNUNET_free(o);
-          GNUNET_free(sec_name);
-          return GNUNET_SYSERR;
-        }
+    GNUNET_free (op);
+    GNUNET_free (op_name);
 
-      GNUNET_CONTAINER_DLL_insert_tail(cur->head, cur->tail, o);
-      op_counter++;
+    if (GNUNET_SYSERR == res)
+    {
+      GNUNET_free (o);
+      GNUNET_free (sec_name);
+      return GNUNET_SYSERR;
     }
-  GNUNET_free(sec_name);
+
+    GNUNET_CONTAINER_DLL_insert_tail (cur->head, cur->tail, o);
+    op_counter++;
+  }
+  GNUNET_free (sec_name);
   return GNUNET_OK;
 }
 
 static int
-load_episodes(struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg)
+load_episodes (struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int e_counter = 0;
   char *sec_name;
@@ -2130,87 +2217,92 @@ load_episodes(struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg)
   e_counter = 0;
   last = NULL;
   while (1)
+  {
+    GNUNET_asprintf (&sec_name, "episode-%u", e_counter);
+    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
+                                                              sec_name,
+                                                              "duration",
+                                                              &e_duration))
     {
-      GNUNET_asprintf(&sec_name, "episode-%u", e_counter);
-      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                               sec_name, "duration", &e_duration))
-        {
-          GNUNET_free(sec_name);
-          break;
-        }
-
-      cur = GNUNET_new(struct Episode);
-      cur->duration = e_duration;
-      cur->id = e_counter;
-
-      if (GNUNET_OK != load_episode(e, cur, cfg))
-        {
-          GNUNET_free(sec_name);
-          GNUNET_free(cur);
-          return GNUNET_SYSERR;
-        }
-
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found episode %u with duration %s \n",
-                 e_counter,
-                 GNUNET_STRINGS_relative_time_to_string(cur->duration, GNUNET_YES));
+      GNUNET_free (sec_name);
+      break;
+    }
 
-      /* Update experiment */
-      e->num_episodes++;
-      e->total_duration = GNUNET_TIME_relative_add(e->total_duration, cur->duration);
-      /* Put in linked list */
-      if (NULL == last)
-        e->start = cur;
-      else
-        last->next = cur;
+    cur = GNUNET_new (struct Episode);
+    cur->duration = e_duration;
+    cur->id = e_counter;
 
-      GNUNET_free(sec_name);
-      e_counter++;
-      last = cur;
+    if (GNUNET_OK != load_episode (e, cur, cfg))
+    {
+      GNUNET_free (sec_name);
+      GNUNET_free (cur);
+      return GNUNET_SYSERR;
     }
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Found episode %u with duration %s \n",
+                e_counter,
+                GNUNET_STRINGS_relative_time_to_string (cur->duration,
+                                                        GNUNET_YES));
+
+    /* Update experiment */
+    e->num_episodes++;
+    e->total_duration = GNUNET_TIME_relative_add (e->total_duration,
+                                                  cur->duration);
+    /* Put in linked list */
+    if (NULL == last)
+      e->start = cur;
+    else
+      last->next = cur;
+
+    GNUNET_free (sec_name);
+    e_counter++;
+    last = cur;
+  }
   return e_counter;
 }
 
 
 static void
-timeout_experiment(void *cls)
+timeout_experiment (void *cls)
 {
   struct Experiment *e = cls;
 
   e->experiment_timeout_task = NULL;
-  fprintf(stderr, "Experiment timeout!\n");
+  fprintf (stderr, "Experiment timeout!\n");
 
   if (NULL != e->episode_timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(e->episode_timeout_task);
-      e->episode_timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (e->episode_timeout_task);
+    e->episode_timeout_task = NULL;
+  }
 
-  e->e_done_cb(e, GNUNET_TIME_absolute_get_duration(e->start_time),
-               GNUNET_SYSERR);
+  e->e_done_cb (e, GNUNET_TIME_absolute_get_duration (e->start_time),
+                GNUNET_SYSERR);
 }
 
 struct ATS_Address *
-create_ats_address(const struct GNUNET_PeerIdentity *peer,
-                   const char *plugin_name,
-                   const void *plugin_addr,
-                   size_t plugin_addr_len,
-                   uint32_t session_id,
-                   uint32_t network)
+create_ats_address (const struct GNUNET_PeerIdentity *peer,
+                    const char *plugin_name,
+                    const void *plugin_addr,
+                    size_t plugin_addr_len,
+                    uint32_t session_id,
+                    uint32_t network)
 {
   struct ATS_Address *aa = NULL;
 
-  aa = GNUNET_malloc(sizeof(struct ATS_Address) + plugin_addr_len + strlen(plugin_name) + 1);
-  aa->atsi = GNUNET_new(struct GNUNET_ATS_Information);
-  aa->atsi[0].type = htonl(GNUNET_ATS_NETWORK_TYPE);
-  aa->atsi[0].value = htonl(network);
+  aa = GNUNET_malloc (sizeof(struct ATS_Address) + plugin_addr_len + strlen (
+                        plugin_name) + 1);
+  aa->atsi = GNUNET_new (struct GNUNET_ATS_Information);
+  aa->atsi[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
+  aa->atsi[0].value = htonl (network);
   aa->atsi_count = 1;
 
   aa->peer = *peer;
   aa->addr_len = plugin_addr_len;
   aa->addr = &aa[1];
-  aa->plugin = (char *)&aa[1] + plugin_addr_len;
-  GNUNET_memcpy(&aa[1], plugin_addr, plugin_addr_len);
-  GNUNET_memcpy(aa->plugin, plugin_name, strlen(plugin_name) + 1);
+  aa->plugin = (char *) &aa[1] + plugin_addr_len;
+  GNUNET_memcpy (&aa[1], plugin_addr, plugin_addr_len);
+  GNUNET_memcpy (aa->plugin, plugin_name, strlen (plugin_name) + 1);
   aa->session_id = session_id;
 
   return aa;
@@ -2219,529 +2311,563 @@ create_ats_address(const struct GNUNET_PeerIdentity *peer,
 
 
 static void
-enforce_add_address(struct GNUNET_ATS_TEST_Operation *op)
+enforce_add_address (struct GNUNET_ATS_TEST_Operation *op)
 {
   struct TestPeer *p;
   struct TestAddress *a;
   int c;
 
-  if (NULL == (p = find_peer_by_id(op->peer_id)))
+  if (NULL == (p = find_peer_by_id (op->peer_id)))
+  {
+    p = GNUNET_new (struct TestPeer);
+    p->id = op->peer_id;
+    p->assigned_bw_in = 0;
+    p->assigned_bw_out = 0;
+    memset (&p->peer_id, op->peer_id, sizeof(p->peer_id));
+    for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
     {
-      p = GNUNET_new(struct TestPeer);
-      p->id = op->peer_id;
-      p->assigned_bw_in = 0;
-      p->assigned_bw_out = 0;
-      memset(&p->peer_id, op->peer_id, sizeof(p->peer_id));
-      for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
-        {
-          p->pref_abs[c] = DEFAULT_ABS_PREFERENCE;
-          p->pref_norm[c] = DEFAULT_REL_PREFERENCE;
-        }
-
-      GNUNET_CONTAINER_DLL_insert(peer_head, peer_tail, p);
+      p->pref_abs[c] = DEFAULT_ABS_PREFERENCE;
+      p->pref_norm[c] = DEFAULT_REL_PREFERENCE;
     }
 
-  if (NULL != (find_address_by_id(p, op->address_id)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Duplicate address %u for peer %u\n",
-                 op->address_id, op->peer_id);
-      return;
-    }
+    GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, p);
+  }
 
-  a = GNUNET_new(struct TestAddress);
+  if (NULL != (find_address_by_id (p, op->address_id)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Duplicate address %u for peer %u\n",
+                op->address_id, op->peer_id);
+    return;
+  }
+
+  a = GNUNET_new (struct TestAddress);
   a->aid = op->address_id;
   a->network = op->address_network;
-  a->ats_addr = create_ats_address(&p->peer_id, op->plugin, op->address,
-                                   strlen(op->address) + 1, op->address_session, op->address_network);
-  memset(&p->peer_id, op->peer_id, sizeof(p->peer_id));
-  GNUNET_CONTAINER_DLL_insert_tail(p->addr_head, p->addr_tail, a);
+  a->ats_addr = create_ats_address (&p->peer_id, op->plugin, op->address,
+                                    strlen (op->address) + 1,
+                                    op->address_session, op->address_network);
+  memset (&p->peer_id, op->peer_id, sizeof(p->peer_id));
+  GNUNET_CONTAINER_DLL_insert_tail (p->addr_head, p->addr_tail, a);
 
   for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
     a->prop_norm[c] = DEFAULT_REL_QUALITY;
 
-  GNUNET_CONTAINER_multipeermap_put(sh->addresses, &p->peer_id, a->ats_addr,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_CONTAINER_multipeermap_put (sh->addresses, &p->peer_id, a->ats_addr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Adding address %u for peer %u in network `%s'\n",
-             op->address_id, op->peer_id, GNUNET_NT_to_string(a->network));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Adding address %u for peer %u in network `%s'\n",
+              op->address_id, op->peer_id, GNUNET_NT_to_string (a->network));
 
-  sh->sf->s_add(sh->sf->cls, a->ats_addr, op->address_network);
+  sh->sf->s_add (sh->sf->cls, a->ats_addr, op->address_network);
 }
 
 
 static void
-enforce_del_address(struct GNUNET_ATS_TEST_Operation *op)
+enforce_del_address (struct GNUNET_ATS_TEST_Operation *op)
 {
   struct TestPeer *p;
   struct TestAddress *a;
   struct PropertyGenerator *pg;
 
-  if (NULL == (p = find_peer_by_id(op->peer_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Deleting address for unknown peer %u\n", op->peer_id);
-      return;
-    }
+  if (NULL == (p = find_peer_by_id (op->peer_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Deleting address for unknown peer %u\n", op->peer_id);
+    return;
+  }
 
-  if (NULL == (a = find_address_by_id(p, op->address_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Deleting address for unknown peer %u\n", op->peer_id);
-      return;
-    }
+  if (NULL == (a = find_address_by_id (p, op->address_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Deleting address for unknown peer %u\n", op->peer_id);
+    return;
+  }
 
-  while (NULL != (pg = find_prop_gen(p->id, a->aid, 0)))
-    {
-      GNUNET_ATS_solver_generate_property_stop(pg);
-    }
+  while (NULL != (pg = find_prop_gen (p->id, a->aid, 0)))
+  {
+    GNUNET_ATS_solver_generate_property_stop (pg);
+  }
 
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(sh->addresses,
-                                                     &p->peer_id,
-                                                     a->ats_addr));
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Removing address %u for peer %u\n",
-             op->address_id,
-             op->peer_id);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (sh->addresses,
+                                                       &p->peer_id,
+                                                       a->ats_addr));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Removing address %u for peer %u\n",
+              op->address_id,
+              op->peer_id);
 
-  sh->sf->s_del(sh->sf->cls, a->ats_addr);
+  sh->sf->s_del (sh->sf->cls, a->ats_addr);
 
   if (NULL != l)
-    {
-      GNUNET_ATS_solver_logging_now(l);
-    }
-  GNUNET_CONTAINER_DLL_remove(p->addr_head, p->addr_tail, a);
+  {
+    GNUNET_ATS_solver_logging_now (l);
+  }
+  GNUNET_CONTAINER_DLL_remove (p->addr_head, p->addr_tail, a);
 
-  GNUNET_free_non_null(a->ats_addr->atsi);
-  GNUNET_free(a->ats_addr);
-  GNUNET_free(a);
+  GNUNET_free_non_null (a->ats_addr->atsi);
+  GNUNET_free (a->ats_addr);
+  GNUNET_free (a);
 }
 
 static void
-enforce_start_property(struct GNUNET_ATS_TEST_Operation *op)
+enforce_start_property (struct GNUNET_ATS_TEST_Operation *op)
 {
   struct PropertyGenerator *pg;
   struct TestPeer *p;
   struct TestAddress *a;
 
-  if (NULL != (pg = find_prop_gen(op->peer_id, op->address_id, op->prop_type)))
-    {
-      GNUNET_ATS_solver_generate_property_stop(pg);
-      GNUNET_free(pg);
-    }
+  if (NULL != (pg = find_prop_gen (op->peer_id, op->address_id, op->prop_type)))
+  {
+    GNUNET_ATS_solver_generate_property_stop (pg);
+    GNUNET_free (pg);
+  }
 
-  if (NULL == (p = find_peer_by_id(op->peer_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Starting property generation for unknown peer %u\n", op->peer_id);
-      return;
-    }
+  if (NULL == (p = find_peer_by_id (op->peer_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Starting property generation for unknown peer %u\n",
+                op->peer_id);
+    return;
+  }
 
-  if (NULL == (a = find_address_by_id(p, op->address_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Setting property for unknown address %u\n", op->peer_id);
-      return;
-    }
+  if (NULL == (a = find_address_by_id (p, op->address_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Setting property for unknown address %u\n", op->peer_id);
+    return;
+  }
 
-  GNUNET_ATS_solver_generate_property_start(op->peer_id,
-                                            op->address_id,
-                                            p, a,
-                                            op->gen_type,
-                                            op->base_rate,
-                                            op->max_rate,
-                                            op->period,
-                                            op->frequency,
-                                            op->prop_type);
+  GNUNET_ATS_solver_generate_property_start (op->peer_id,
+                                             op->address_id,
+                                             p, a,
+                                             op->gen_type,
+                                             op->base_rate,
+                                             op->max_rate,
+                                             op->period,
+                                             op->frequency,
+                                             op->prop_type);
 }
 
 static void
-enforce_stop_property(struct GNUNET_ATS_TEST_Operation *op)
+enforce_stop_property (struct GNUNET_ATS_TEST_Operation *op)
 {
-  struct PropertyGenerator *pg = find_prop_gen(op->peer_id, op->address_id,
-                                               op->prop_type);
+  struct PropertyGenerator *pg = find_prop_gen (op->peer_id, op->address_id,
+                                                op->prop_type);
 
   if (NULL != pg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Stopping preference generation for peer %u address %u\n", op->peer_id,
-                 op->address_id);
-      GNUNET_ATS_solver_generate_property_stop(pg);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Stopping preference generation for peer %u address %u\n",
+                op->peer_id,
+                op->address_id);
+    GNUNET_ATS_solver_generate_property_stop (pg);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Cannot find preference generator for peer %u address %u\n",
-                 op->peer_id, op->address_id);
-      GNUNET_break(0);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Cannot find preference generator for peer %u address %u\n",
+                op->peer_id, op->address_id);
+    GNUNET_break (0);
+  }
 }
 
 static void
-enforce_start_preference(struct GNUNET_ATS_TEST_Operation *op)
+enforce_start_preference (struct GNUNET_ATS_TEST_Operation *op)
 {
   struct PreferenceGenerator *pg;
 
-  if (NULL != (pg = find_pref_gen(op->peer_id, op->pref_type)))
-    {
-      GNUNET_ATS_solver_generate_preferences_stop(pg);
-      GNUNET_free(pg);
-    }
+  if (NULL != (pg = find_pref_gen (op->peer_id, op->pref_type)))
+  {
+    GNUNET_ATS_solver_generate_preferences_stop (pg);
+    GNUNET_free (pg);
+  }
 
-  if (NULL == (find_peer_by_id(op->peer_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Starting preference generation for unknown peer %u\n", op->peer_id);
-      return;
-    }
+  if (NULL == (find_peer_by_id (op->peer_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Starting preference generation for unknown peer %u\n",
+                op->peer_id);
+    return;
+  }
 
-  GNUNET_ATS_solver_generate_preferences_start(op->peer_id,
-                                               op->address_id,
-                                               op->client_id,
-                                               op->gen_type,
-                                               op->base_rate,
-                                               op->max_rate,
-                                               op->period,
-                                               op->frequency,
-                                               op->pref_type,
-                                               op->frequency);
+  GNUNET_ATS_solver_generate_preferences_start (op->peer_id,
+                                                op->address_id,
+                                                op->client_id,
+                                                op->gen_type,
+                                                op->base_rate,
+                                                op->max_rate,
+                                                op->period,
+                                                op->frequency,
+                                                op->pref_type,
+                                                op->frequency);
 }
 
 static void
-enforce_stop_preference(struct GNUNET_ATS_TEST_Operation *op)
+enforce_stop_preference (struct GNUNET_ATS_TEST_Operation *op)
 {
-  struct PreferenceGenerator *pg = find_pref_gen(op->peer_id,
-                                                 op->pref_type);
+  struct PreferenceGenerator *pg = find_pref_gen (op->peer_id,
+                                                  op->pref_type);
 
   if (NULL != pg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Stopping property generation for peer %u address %u\n", op->peer_id,
-                 op->address_id);
-      GNUNET_ATS_solver_generate_preferences_stop(pg);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Stopping property generation for peer %u address %u\n",
+                op->peer_id,
+                op->address_id);
+    GNUNET_ATS_solver_generate_preferences_stop (pg);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Cannot find preference generator for peer %u address %u\n",
-                 op->peer_id, op->address_id);
-      GNUNET_break(0);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Cannot find preference generator for peer %u address %u\n",
+                op->peer_id, op->address_id);
+    GNUNET_break (0);
+  }
 }
 
 
 static void
-enforce_start_request(struct GNUNET_ATS_TEST_Operation *op)
+enforce_start_request (struct GNUNET_ATS_TEST_Operation *op)
 {
   struct TestPeer *p;
 
-  if (NULL == (p = find_peer_by_id(op->peer_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Requesting address for unknown peer %u\n", op->peer_id);
-      return;
-    }
+  if (NULL == (p = find_peer_by_id (op->peer_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Requesting address for unknown peer %u\n", op->peer_id);
+    return;
+  }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Requesting address for peer %u\n",
-             op->peer_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Requesting address for peer %u\n",
+              op->peer_id);
   p->is_requested = GNUNET_YES;
 
-  sh->sf->s_get(sh->sf->cls, &p->peer_id);
+  sh->sf->s_get (sh->sf->cls, &p->peer_id);
 }
 
 
 static void
-enforce_stop_request(struct GNUNET_ATS_TEST_Operation *op)
+enforce_stop_request (struct GNUNET_ATS_TEST_Operation *op)
 {
   struct TestPeer *p;
 
-  if (NULL == (p = find_peer_by_id(op->peer_id)))
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Requesting address for unknown peer %u\n", op->peer_id);
-      return;
-    }
+  if (NULL == (p = find_peer_by_id (op->peer_id)))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Requesting address for unknown peer %u\n", op->peer_id);
+    return;
+  }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Stop requesting address for peer %u\n",
-             op->peer_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Stop requesting address for peer %u\n",
+              op->peer_id);
   p->is_requested = GNUNET_NO;
   p->assigned_bw_in = 0;
   p->assigned_bw_out = 0;
-  sh->sf->s_get_stop(sh->sf->cls, &p->peer_id);
+  sh->sf->s_get_stop (sh->sf->cls, &p->peer_id);
 
   if (NULL != l)
-    {
-      GNUNET_ATS_solver_logging_now(l);
-    }
+  {
+    GNUNET_ATS_solver_logging_now (l);
+  }
 }
 
-static void enforce_episode(struct Episode *ep)
+static void enforce_episode (struct Episode *ep)
 {
   struct GNUNET_ATS_TEST_Operation *cur;
 
   for (cur = ep->head; NULL != cur; cur = cur->next)
+  {
+    switch (cur->type)
     {
-      switch (cur->type)
-        {
-        case SOLVER_OP_ADD_ADDRESS:
-          fprintf(stderr, "Enforcing operation: %s [%llu:%llu]\n",
-                  print_op(cur->type), cur->peer_id, cur->address_id);
-          enforce_add_address(cur);
-          break;
-
-        case SOLVER_OP_DEL_ADDRESS:
-          fprintf(stderr, "Enforcing operation: %s [%llu:%llu]\n",
-                  print_op(cur->type), cur->peer_id, cur->address_id);
-          enforce_del_address(cur);
-          break;
-
-        case SOLVER_OP_START_SET_PROPERTY:
-          fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
-                  print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate);
-          enforce_start_property(cur);
-          break;
-
-        case SOLVER_OP_STOP_SET_PROPERTY:
-          fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
-                  print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate);
-          enforce_stop_property(cur);
-          break;
-
-        case SOLVER_OP_START_SET_PREFERENCE:
-          fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
-                  print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate);
-          enforce_start_preference(cur);
-          break;
-
-        case SOLVER_OP_STOP_SET_PREFERENCE:
-          fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
-                  print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate);
-          enforce_stop_preference(cur);
-          break;
-
-        case SOLVER_OP_START_REQUEST:
-          fprintf(stderr, "Enforcing operation: %s [%llu]\n",
-                  print_op(cur->type), cur->peer_id);
-          enforce_start_request(cur);
-          break;
-
-        case SOLVER_OP_STOP_REQUEST:
-          fprintf(stderr, "Enforcing operation: %s [%llu]\n",
-                  print_op(cur->type), cur->peer_id);
-          enforce_stop_request(cur);
-          break;
-
-        default:
-          break;
-        }
+    case SOLVER_OP_ADD_ADDRESS:
+      fprintf (stderr, "Enforcing operation: %s [%llu:%llu]\n",
+               print_op (cur->type), cur->peer_id, cur->address_id);
+      enforce_add_address (cur);
+      break;
+
+    case SOLVER_OP_DEL_ADDRESS:
+      fprintf (stderr, "Enforcing operation: %s [%llu:%llu]\n",
+               print_op (cur->type), cur->peer_id, cur->address_id);
+      enforce_del_address (cur);
+      break;
+
+    case SOLVER_OP_START_SET_PROPERTY:
+      fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
+               print_op (cur->type), cur->peer_id, cur->address_id,
+               cur->base_rate);
+      enforce_start_property (cur);
+      break;
+
+    case SOLVER_OP_STOP_SET_PROPERTY:
+      fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
+               print_op (cur->type), cur->peer_id, cur->address_id,
+               cur->base_rate);
+      enforce_stop_property (cur);
+      break;
+
+    case SOLVER_OP_START_SET_PREFERENCE:
+      fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
+               print_op (cur->type), cur->peer_id, cur->address_id,
+               cur->base_rate);
+      enforce_start_preference (cur);
+      break;
+
+    case SOLVER_OP_STOP_SET_PREFERENCE:
+      fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
+               print_op (cur->type), cur->peer_id, cur->address_id,
+               cur->base_rate);
+      enforce_stop_preference (cur);
+      break;
+
+    case SOLVER_OP_START_REQUEST:
+      fprintf (stderr, "Enforcing operation: %s [%llu]\n",
+               print_op (cur->type), cur->peer_id);
+      enforce_start_request (cur);
+      break;
+
+    case SOLVER_OP_STOP_REQUEST:
+      fprintf (stderr, "Enforcing operation: %s [%llu]\n",
+               print_op (cur->type), cur->peer_id);
+      enforce_stop_request (cur);
+      break;
+
+    default:
+      break;
     }
+  }
 }
 
 
 static void
-timeout_episode(void *cls)
+timeout_episode (void *cls)
 {
   struct Experiment *e = cls;
 
   e->episode_timeout_task = NULL;
   if (NULL != e->ep_done_cb)
-    e->ep_done_cb(e->cur);
+    e->ep_done_cb (e->cur);
 
   /* Scheduling next */
   e->cur = e->cur->next;
   if (NULL == e->cur)
+  {
+    /* done */
+    fprintf (stderr, "Last episode done!\n");
+    if (NULL != e->experiment_timeout_task)
     {
-      /* done */
-      fprintf(stderr, "Last episode done!\n");
-      if (NULL != e->experiment_timeout_task)
-        {
-          GNUNET_SCHEDULER_cancel(e->experiment_timeout_task);
-          e->experiment_timeout_task = NULL;
-        }
-      e->e_done_cb(e, GNUNET_TIME_absolute_get_duration(e->start_time), GNUNET_OK);
-      return;
+      GNUNET_SCHEDULER_cancel (e->experiment_timeout_task);
+      e->experiment_timeout_task = NULL;
     }
+    e->e_done_cb (e, GNUNET_TIME_absolute_get_duration (e->start_time),
+                  GNUNET_OK);
+    return;
+  }
 
-  fprintf(stderr, "Running episode %u with timeout %s\n",
-          e->cur->id,
-          GNUNET_STRINGS_relative_time_to_string(e->cur->duration, GNUNET_YES));
-  e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed(e->cur->duration,
-                                                         &timeout_episode, e);
-  enforce_episode(e->cur);
+  fprintf (stderr, "Running episode %u with timeout %s\n",
+           e->cur->id,
+           GNUNET_STRINGS_relative_time_to_string (e->cur->duration,
+                                                   GNUNET_YES));
+  e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed (e->cur->duration,
+                                                          &timeout_episode, e);
+  enforce_episode (e->cur);
 }
 
 
 void
-GNUNET_ATS_solvers_experimentation_run(struct Experiment *e,
-                                       GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb,
-                                       GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb)
-{
-  fprintf(stderr, "Running experiment `%s'  with timeout %s\n", e->name,
-          GNUNET_STRINGS_relative_time_to_string(e->max_duration, GNUNET_YES));
+GNUNET_ATS_solvers_experimentation_run (struct Experiment *e,
+                                        GNUNET_ATS_TESTING_EpisodeDoneCallback
+                                        ep_done_cb,
+                                        GNUNET_ATS_TESTING_ExperimentDoneCallback
+                                        e_done_cb)
+{
+  fprintf (stderr, "Running experiment `%s'  with timeout %s\n", e->name,
+           GNUNET_STRINGS_relative_time_to_string (e->max_duration,
+                                                   GNUNET_YES));
   e->e_done_cb = e_done_cb;
   e->ep_done_cb = ep_done_cb;
-  e->start_time = GNUNET_TIME_absolute_get();
+  e->start_time = GNUNET_TIME_absolute_get ();
 
   /* Start total time out */
-  e->experiment_timeout_task = GNUNET_SCHEDULER_add_delayed(e->max_duration,
-                                                            &timeout_experiment, e);
+  e->experiment_timeout_task = GNUNET_SCHEDULER_add_delayed (e->max_duration,
+                                                             &timeout_experiment,
+                                                             e);
 
   /* Start */
   if (NULL == e->start)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
 
   e->cur = e->start;
-  fprintf(stderr, "Running episode %u with timeout %s\n",
-          e->cur->id,
-          GNUNET_STRINGS_relative_time_to_string(e->cur->duration, GNUNET_YES));
-  e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed(e->cur->duration,
-                                                         &timeout_episode, e);
-  enforce_episode(e->cur);
+  fprintf (stderr, "Running episode %u with timeout %s\n",
+           e->cur->id,
+           GNUNET_STRINGS_relative_time_to_string (e->cur->duration,
+                                                   GNUNET_YES));
+  e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed (e->cur->duration,
+                                                          &timeout_episode, e);
+  enforce_episode (e->cur);
 }
 
 void
-GNUNET_ATS_solvers_experimentation_stop(struct Experiment *e)
+GNUNET_ATS_solvers_experimentation_stop (struct Experiment *e)
 {
   if (NULL != e->experiment_timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(e->experiment_timeout_task);
-      e->experiment_timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (e->experiment_timeout_task);
+    e->experiment_timeout_task = NULL;
+  }
   if (NULL != e->episode_timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(e->episode_timeout_task);
-      e->episode_timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (e->episode_timeout_task);
+    e->episode_timeout_task = NULL;
+  }
   if (NULL != e->cfg)
-    {
-      GNUNET_CONFIGURATION_destroy(e->cfg);
-      e->cfg = NULL;
-    }
-  free_experiment(e);
+  {
+    GNUNET_CONFIGURATION_destroy (e->cfg);
+    e->cfg = NULL;
+  }
+  free_experiment (e);
 }
 
 
 struct Experiment *
-GNUNET_ATS_solvers_experimentation_load(char *filename)
+GNUNET_ATS_solvers_experimentation_load (char *filename)
 {
   struct Experiment *e;
   struct GNUNET_CONFIGURATION_Handle *cfg;
 
   e = NULL;
 
-  cfg = GNUNET_CONFIGURATION_create();
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, filename))
-    {
-      fprintf(stderr, "Failed to load `%s'\n", filename);
-      GNUNET_CONFIGURATION_destroy(cfg);
-      return NULL;
-    }
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, filename))
+  {
+    fprintf (stderr, "Failed to load `%s'\n", filename);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    return NULL;
+  }
 
-  e = create_experiment();
+  e = create_experiment ();
 
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "experiment",
-                                                             "name", &e->name))
-    {
-      fprintf(stderr, "Invalid %s \n", "name");
-      free_experiment(e);
-      return NULL;
-    }
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, "experiment",
+                                                              "name", &e->name))
+  {
+    fprintf (stderr, "Invalid %s \n", "name");
+    free_experiment (e);
+    return NULL;
+  }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment name: `%s'\n", e->name);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment name: `%s'\n", e->name);
 
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "experiment",
-                                                             "log_prefix", &e->log_prefix))
-    {
-      fprintf(stderr, "Invalid %s \n", "log_prefix");
-      free_experiment(e);
-      return NULL;
-    }
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, "experiment",
+                                                              "log_prefix",
+                                                              &e->log_prefix))
+  {
+    fprintf (stderr, "Invalid %s \n", "log_prefix");
+    free_experiment (e);
+    return NULL;
+  }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging prefix: `%s'\n",
-               e->log_prefix);
-
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename(cfg, "experiment",
-                                                               "log_output_dir", &e->log_output_dir))
-    {
-      e->log_output_dir = NULL;
-    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment logging prefix: `%s'\n",
+                e->log_prefix);
+
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                                "experiment",
+                                                                "log_output_dir",
+                                                                &e->
+                                                                log_output_dir))
+  {
+    e->log_output_dir = NULL;
+  }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging output directory: `%s'\n",
-               e->log_output_dir);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Experiment logging output directory: `%s'\n",
+                e->log_output_dir);
 
 
-  if (GNUNET_SYSERR == (e->log_append_time_stamp = GNUNET_CONFIGURATION_get_value_yesno(cfg,
-                                                                                        "experiment", "log_append_time_stamp")))
+  if (GNUNET_SYSERR == (e->log_append_time_stamp =
+                          GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                                                "experiment",
+                                                                "log_append_time_stamp")))
     e->log_append_time_stamp = GNUNET_YES;
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging append timestamp: `%s'\n",
-             (GNUNET_YES == e->log_append_time_stamp) ? "yes" : "no");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Experiment logging append timestamp: `%s'\n",
+              (GNUNET_YES == e->log_append_time_stamp) ? "yes" : "no");
 
 
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename(cfg, "experiment",
-                                                               "cfg_file", &e->cfg_file))
-    {
-      fprintf(stderr, "Invalid %s \n", "cfg_file");
-      free_experiment(e);
-      return NULL;
-    }
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                                "experiment",
+                                                                "cfg_file",
+                                                                &e->cfg_file))
+  {
+    fprintf (stderr, "Invalid %s \n", "cfg_file");
+    free_experiment (e);
+    return NULL;
+  }
   else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment configuration: `%s'\n",
+                e->cfg_file);
+    e->cfg = GNUNET_CONFIGURATION_create ();
+    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (e->cfg, e->cfg_file))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment configuration: `%s'\n", e->cfg_file);
-      e->cfg = GNUNET_CONFIGURATION_create();
-      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(e->cfg, e->cfg_file))
-        {
-          fprintf(stderr, "Invalid configuration %s \n", "cfg_file");
-          free_experiment(e);
-          return NULL;
-        }
-    }
-
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, "experiment",
-                                                           "log_freq", &e->log_freq))
-    {
-      fprintf(stderr, "Invalid %s \n", "log_freq");
-      free_experiment(e);
+      fprintf (stderr, "Invalid configuration %s \n", "cfg_file");
+      free_experiment (e);
       return NULL;
     }
-  else
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging frequency: `%s'\n",
-               GNUNET_STRINGS_relative_time_to_string(e->log_freq, GNUNET_YES));
+  }
 
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, "experiment",
-                                                           "max_duration", &e->max_duration))
-    {
-      fprintf(stderr, "Invalid %s", "max_duration");
-      free_experiment(e);
-      return NULL;
-    }
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, "experiment",
+                                                            "log_freq",
+                                                            &e->log_freq))
+  {
+    fprintf (stderr, "Invalid %s \n", "log_freq");
+    free_experiment (e);
+    return NULL;
+  }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment duration: `%s'\n",
-               GNUNET_STRINGS_relative_time_to_string(e->max_duration, GNUNET_YES));
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment logging frequency: `%s'\n",
+                GNUNET_STRINGS_relative_time_to_string (e->log_freq,
+                                                        GNUNET_YES));
 
-  if (GNUNET_SYSERR == load_episodes(e, cfg))
-    {
-      GNUNET_ATS_solvers_experimentation_stop(e);
-      GNUNET_CONFIGURATION_destroy(cfg);
-      e = NULL;
-      fprintf(stderr, "Failed to load experiment\n");
-      return NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Loaded %u episodes with total duration %s\n",
-             e->num_episodes,
-             GNUNET_STRINGS_relative_time_to_string(e->total_duration, GNUNET_YES));
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, "experiment",
+                                                            "max_duration",
+                                                            &e->max_duration))
+  {
+    fprintf (stderr, "Invalid %s", "max_duration");
+    free_experiment (e);
+    return NULL;
+  }
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment duration: `%s'\n",
+                GNUNET_STRINGS_relative_time_to_string (e->max_duration,
+                                                        GNUNET_YES));
 
-  GNUNET_CONFIGURATION_destroy(cfg);
+  if (GNUNET_SYSERR == load_episodes (e, cfg))
+  {
+    GNUNET_ATS_solvers_experimentation_stop (e);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    e = NULL;
+    fprintf (stderr, "Failed to load experiment\n");
+    return NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Loaded %u episodes with total duration %s\n",
+              e->num_episodes,
+              GNUNET_STRINGS_relative_time_to_string (e->total_duration,
+                                                      GNUNET_YES));
+
+  GNUNET_CONFIGURATION_destroy (cfg);
   return e;
 }
 
@@ -2752,34 +2878,35 @@ GNUNET_ATS_solvers_experimentation_load(char *filename)
  */
 
 static int
-free_all_it(void *cls,
-            const struct GNUNET_PeerIdentity *key,
-            void *value)
+free_all_it (void *cls,
+             const struct GNUNET_PeerIdentity *key,
+             void *value)
 {
   struct ATS_Address *address = value;
 
-  GNUNET_break(GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove(sh->env.addresses,
-                                                                 key, value));
-  GNUNET_free(address);
+  GNUNET_break (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (
+                  sh->env.addresses,
+                  key, value));
+  GNUNET_free (address);
 
   return GNUNET_OK;
 }
 
 void
-GNUNET_ATS_solvers_solver_stop(struct SolverHandle *sh)
+GNUNET_ATS_solvers_solver_stop (struct SolverHandle *sh)
 {
-  GNUNET_STATISTICS_destroy((struct GNUNET_STATISTICS_Handle *)sh->env.stats,
-                            GNUNET_NO);
-  GNUNET_PLUGIN_unload(sh->plugin, sh->sf);
+  GNUNET_STATISTICS_destroy ((struct GNUNET_STATISTICS_Handle *) sh->env.stats,
+                             GNUNET_NO);
+  GNUNET_PLUGIN_unload (sh->plugin, sh->sf);
   sh->sf = NULL;
-  GAS_normalization_stop();
+  GAS_normalization_stop ();
 
-  GNUNET_CONTAINER_multipeermap_iterate(sh->addresses,
-                                        &free_all_it,
-                                        NULL);
-  GNUNET_CONTAINER_multipeermap_destroy(sh->addresses);
-  GNUNET_free(sh->plugin);
-  GNUNET_free(sh);
+  GNUNET_CONTAINER_multipeermap_iterate (sh->addresses,
+                                         &free_all_it,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (sh->addresses);
+  GNUNET_free (sh->plugin);
+  GNUNET_free (sh);
 }
 
 
@@ -2793,118 +2920,141 @@ GNUNET_ATS_solvers_solver_stop(struct SolverHandle *sh)
  * @return number of networks loaded
  */
 unsigned int
-GNUNET_ATS_solvers_load_quotas(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                               unsigned long long *out_dest,
-                               unsigned long long *in_dest,
-                               int dest_length)
-{
-  char * entry_in = NULL;
-  char * entry_out = NULL;
-  char * quota_out_str;
-  char * quota_in_str;
+GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                unsigned long long *out_dest,
+                                unsigned long long *in_dest,
+                                int dest_length)
+{
+  char *entry_in = NULL;
+  char *entry_out = NULL;
+  char *quota_out_str;
+  char *quota_in_str;
   int c;
   int res;
 
   for (c = 0; (c < GNUNET_NT_COUNT) && (c < dest_length); c++)
-    {
-      in_dest[c] = 0;
-      out_dest[c] = 0;
-      GNUNET_asprintf(&entry_out,
-                      "%s_QUOTA_OUT",
-                      GNUNET_NT_to_string(c));
-      GNUNET_asprintf(&entry_in,
-                      "%s_QUOTA_IN",
-                      GNUNET_NT_to_string(c));
-
-      /* quota out */
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, &quota_out_str))
-        {
-          res = GNUNET_NO;
-          if (0 == strcmp(quota_out_str, BIG_M_STRING))
-            {
-              out_dest[c] = GNUNET_ATS_MaxBandwidth;
-              res = GNUNET_YES;
-            }
-          if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_STRINGS_fancy_size_to_bytes(quota_out_str, &out_dest[c])))
-            res = GNUNET_YES;
-          if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "ats", entry_out, &out_dest[c])))
-            res = GNUNET_YES;
-
-          if (GNUNET_NO == res)
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-                         GNUNET_NT_to_string(c),
-                         quota_out_str,
-                         GNUNET_ATS_DefaultBandwidth);
-              out_dest[c] = GNUNET_ATS_DefaultBandwidth;
-            }
-          else
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                         "Outbound quota configure for network `%s' is %llu\n",
-                         GNUNET_NT_to_string(c),
-                         out_dest[c]);
-            }
-          GNUNET_free(quota_out_str);
-        }
+  {
+    in_dest[c] = 0;
+    out_dest[c] = 0;
+    GNUNET_asprintf (&entry_out,
+                     "%s_QUOTA_OUT",
+                     GNUNET_NT_to_string (c));
+    GNUNET_asprintf (&entry_in,
+                     "%s_QUOTA_IN",
+                     GNUNET_NT_to_string (c));
+
+    /* quota out */
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, "ats",
+                                                            entry_out,
+                                                            &quota_out_str))
+    {
+      res = GNUNET_NO;
+      if (0 == strcmp (quota_out_str, BIG_M_STRING))
+      {
+        out_dest[c] = GNUNET_ATS_MaxBandwidth;
+        res = GNUNET_YES;
+      }
+      if ((GNUNET_NO == res) && (GNUNET_OK ==
+                                 GNUNET_STRINGS_fancy_size_to_bytes (
+                                   quota_out_str, &out_dest[c])))
+        res = GNUNET_YES;
+      if ((GNUNET_NO == res) && (GNUNET_OK ==
+                                 GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                                        "ats",
+                                                                        entry_out,
+                                                                        &
+                                                                        out_dest
+                                                                        [c])))
+        res = GNUNET_YES;
+
+      if (GNUNET_NO == res)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ (
+                      "Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                    GNUNET_NT_to_string (c),
+                    quota_out_str,
+                    GNUNET_ATS_DefaultBandwidth);
+        out_dest[c] = GNUNET_ATS_DefaultBandwidth;
+      }
       else
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                     _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
-                     GNUNET_NT_to_string(c),
-                     GNUNET_ATS_DefaultBandwidth);
-          out_dest[c] = GNUNET_ATS_DefaultBandwidth;
-        }
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Outbound quota configure for network `%s' is %llu\n",
+                    GNUNET_NT_to_string (c),
+                    out_dest[c]);
+      }
+      GNUNET_free (quota_out_str);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _ (
+                    "No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
+                  GNUNET_NT_to_string (c),
+                  GNUNET_ATS_DefaultBandwidth);
+      out_dest[c] = GNUNET_ATS_DefaultBandwidth;
+    }
 
-      /* quota in */
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_in, &quota_in_str))
-        {
-          res = GNUNET_NO;
-          if (0 == strcmp(quota_in_str, BIG_M_STRING))
-            {
-              in_dest[c] = GNUNET_ATS_MaxBandwidth;
-              res = GNUNET_YES;
-            }
-          if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_STRINGS_fancy_size_to_bytes(quota_in_str, &in_dest[c])))
-            res = GNUNET_YES;
-          if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "ats", entry_in, &in_dest[c])))
-            res = GNUNET_YES;
-
-          if (GNUNET_NO == res)
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-                         GNUNET_NT_to_string(c),
-                         quota_in_str,
-                         GNUNET_ATS_DefaultBandwidth);
-              in_dest[c] = GNUNET_ATS_DefaultBandwidth;
-            }
-          else
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                         "Inbound quota configured for network `%s' is %llu\n",
-                         GNUNET_NT_to_string(c),
-                         in_dest[c]);
-            }
-          GNUNET_free(quota_in_str);
-        }
+    /* quota in */
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, "ats",
+                                                            entry_in,
+                                                            &quota_in_str))
+    {
+      res = GNUNET_NO;
+      if (0 == strcmp (quota_in_str, BIG_M_STRING))
+      {
+        in_dest[c] = GNUNET_ATS_MaxBandwidth;
+        res = GNUNET_YES;
+      }
+      if ((GNUNET_NO == res) && (GNUNET_OK ==
+                                 GNUNET_STRINGS_fancy_size_to_bytes (
+                                   quota_in_str, &in_dest[c])))
+        res = GNUNET_YES;
+      if ((GNUNET_NO == res) && (GNUNET_OK ==
+                                 GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                                        "ats",
+                                                                        entry_in,
+                                                                        &in_dest
+                                                                        [c])))
+        res = GNUNET_YES;
+
+      if (GNUNET_NO == res)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ (
+                      "Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                    GNUNET_NT_to_string (c),
+                    quota_in_str,
+                    GNUNET_ATS_DefaultBandwidth);
+        in_dest[c] = GNUNET_ATS_DefaultBandwidth;
+      }
       else
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                     _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
-                     GNUNET_NT_to_string(c),
-                     GNUNET_ATS_DefaultBandwidth);
-          out_dest[c] = GNUNET_ATS_DefaultBandwidth;
-        }
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Loaded quota for network `%s' (in/out): %llu %llu\n",
-                 GNUNET_NT_to_string(c),
-                 in_dest[c],
-                 out_dest[c]);
-      GNUNET_free(entry_out);
-      GNUNET_free(entry_in);
-    }
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Inbound quota configured for network `%s' is %llu\n",
+                    GNUNET_NT_to_string (c),
+                    in_dest[c]);
+      }
+      GNUNET_free (quota_in_str);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _ (
+                    "No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
+                  GNUNET_NT_to_string (c),
+                  GNUNET_ATS_DefaultBandwidth);
+      out_dest[c] = GNUNET_ATS_DefaultBandwidth;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Loaded quota for network `%s' (in/out): %llu %llu\n",
+                GNUNET_NT_to_string (c),
+                in_dest[c],
+                out_dest[c]);
+    GNUNET_free (entry_out);
+    GNUNET_free (entry_in);
+  }
   return GNUNET_NT_COUNT;
 }
 
@@ -2918,109 +3068,118 @@ GNUNET_ATS_solvers_load_quotas(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param add additional solver information
  */
 static void
-solver_info_cb(void *cls,
-               enum GAS_Solver_Operation op,
-               enum GAS_Solver_Status stat,
-               enum GAS_Solver_Additional_Information add)
+solver_info_cb (void *cls,
+                enum GAS_Solver_Operation op,
+                enum GAS_Solver_Status stat,
+                enum GAS_Solver_Additional_Information add)
 {
   char *add_info;
 
   switch (add)
-    {
-    case GAS_INFO_NONE:
-      add_info = "GAS_INFO_NONE";
-      break;
+  {
+  case GAS_INFO_NONE:
+    add_info = "GAS_INFO_NONE";
+    break;
 
-    case GAS_INFO_FULL:
-      add_info = "GAS_INFO_MLP_FULL";
-      break;
+  case GAS_INFO_FULL:
+    add_info = "GAS_INFO_MLP_FULL";
+    break;
 
-    case GAS_INFO_UPDATED:
-      add_info = "GAS_INFO_MLP_UPDATED";
-      break;
+  case GAS_INFO_UPDATED:
+    add_info = "GAS_INFO_MLP_UPDATED";
+    break;
 
-    case GAS_INFO_PROP_ALL:
-      add_info = "GAS_INFO_PROP_ALL";
-      break;
+  case GAS_INFO_PROP_ALL:
+    add_info = "GAS_INFO_PROP_ALL";
+    break;
 
-    case GAS_INFO_PROP_SINGLE:
-      add_info = "GAS_INFO_PROP_SINGLE";
-      break;
+  case GAS_INFO_PROP_SINGLE:
+    add_info = "GAS_INFO_PROP_SINGLE";
+    break;
 
-    default:
-      add_info = "INVALID";
-      break;
-    }
+  default:
+    add_info = "INVALID";
+    break;
+  }
 
   switch (op)
-    {
-    case GAS_OP_SOLVE_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s' `%s'\n", "GAS_OP_SOLVE_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
-      return;
+  {
+  case GAS_OP_SOLVE_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s' `%s'\n",
+                "GAS_OP_SOLVE_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
+    return;
 
-    case GAS_OP_SOLVE_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
-      return;
+  case GAS_OP_SOLVE_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
+    return;
 
-    case GAS_OP_SOLVE_SETUP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_SETUP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_SETUP_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    case GAS_OP_SOLVE_SETUP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_SETUP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_SETUP_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    case GAS_OP_SOLVE_MLP_LP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_MLP_LP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_LP_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    case GAS_OP_SOLVE_MLP_LP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_MLP_LP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_LP_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    case GAS_OP_SOLVE_MLP_MLP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_MLP_MLP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_MLP_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    case GAS_OP_SOLVE_MLP_MLP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_MLP_MLP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_MLP_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+  case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    default:
-      break;
-    }
+  default:
+    break;
+  }
 }
 
 static void
-solver_bandwidth_changed_cb(void *cls, struct ATS_Address *address)
+solver_bandwidth_changed_cb (void *cls, struct ATS_Address *address)
 {
   struct GNUNET_TIME_Relative duration;
   struct TestPeer *p;
@@ -3028,99 +3187,100 @@ solver_bandwidth_changed_cb(void *cls, struct ATS_Address *address)
   uint32_t delta;
 
   if ((0 == address->assigned_bw_out) && (0 == address->assigned_bw_in))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notified to disconnect peer `%s'\n",
-                 GNUNET_i2s(&address->peer));
-    }
-  p = find_peer_by_pid(&address->peer);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notified to disconnect peer `%s'\n",
+                GNUNET_i2s (&address->peer));
+  }
+  p = find_peer_by_pid (&address->peer);
   if (NULL == p)
     return;
   p->assigned_bw_out = address->assigned_bw_out;
   p->assigned_bw_in = address->assigned_bw_in;
 
   for (pg = pref_gen_head; NULL != pg; pg = pg->next)
+  {
+    if (pg->peer == p->id)
     {
-      if (pg->peer == p->id)
-        {
-          duration = GNUNET_TIME_absolute_get_duration(pg->feedback_last_bw_update);
-          delta = duration.rel_value_us * pg->last_assigned_bw_out;
-          pg->feedback_bw_out_acc += delta;
+      duration = GNUNET_TIME_absolute_get_duration (
+        pg->feedback_last_bw_update);
+      delta = duration.rel_value_us * pg->last_assigned_bw_out;
+      pg->feedback_bw_out_acc += delta;
 
-          delta = duration.rel_value_us * pg->last_assigned_bw_in;
-          pg->feedback_bw_in_acc += delta;
+      delta = duration.rel_value_us * pg->last_assigned_bw_in;
+      pg->feedback_bw_in_acc += delta;
 
-          pg->last_assigned_bw_in = address->assigned_bw_in;
-          pg->last_assigned_bw_out = address->assigned_bw_out;
-          pg->feedback_last_bw_update = GNUNET_TIME_absolute_get();
-        }
+      pg->last_assigned_bw_in = address->assigned_bw_in;
+      pg->last_assigned_bw_out = address->assigned_bw_out;
+      pg->feedback_last_bw_update = GNUNET_TIME_absolute_get ();
     }
+  }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Bandwidth changed addresses %s %p to %u Bps out / %u Bps in\n",
-             GNUNET_i2s(&address->peer),
-             address,
-             address->assigned_bw_out,
-             address->assigned_bw_in);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Bandwidth changed addresses %s %p to %u Bps out / %u Bps in\n",
+              GNUNET_i2s (&address->peer),
+              address,
+              address->assigned_bw_out,
+              address->assigned_bw_in);
 
   if (NULL != l)
-    GNUNET_ATS_solver_logging_now(l);
+    GNUNET_ATS_solver_logging_now (l);
 
   return;
 }
 
 const double *
-get_preferences_cb(void *cls, const struct GNUNET_PeerIdentity *id)
+get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id)
 {
   struct TestPeer *p;
 
   if (GNUNET_YES == opt_disable_normalization)
-    {
-      if (NULL == (p = find_peer_by_pid(id)))
-        return NULL;
-      return p->pref_abs;
-    }
+  {
+    if (NULL == (p = find_peer_by_pid (id)))
+      return NULL;
+    return p->pref_abs;
+  }
   else
-    return GAS_preference_get_by_peer(NULL,
-                                      id);
+    return GAS_preference_get_by_peer (NULL,
+                                       id);
 }
 
 
 struct SolverHandle *
-GNUNET_ATS_solvers_solver_start(enum GNUNET_ATS_Solvers type)
+GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
 {
   struct SolverHandle *sh;
-  char * solver_str;
+  char *solver_str;
 
   switch (type)
-    {
-    case GNUNET_ATS_SOLVER_PROPORTIONAL:
-      solver_str = "proportional";
-      break;
-
-    case GNUNET_ATS_SOLVER_MLP:
-      solver_str = "mlp";
-      break;
-
-    case GNUNET_ATS_SOLVER_RIL:
-      solver_str = "ril";
-      break;
-
-    default:
-      GNUNET_break(0);
-      return NULL;
-      break;
-    }
-
-  sh = GNUNET_new(struct SolverHandle);
-  GNUNET_asprintf(&sh->plugin,
-                  "libgnunet_plugin_ats_%s",
-                  solver_str);
-  sh->addresses = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_NO);
+  {
+  case GNUNET_ATS_SOLVER_PROPORTIONAL:
+    solver_str = "proportional";
+    break;
+
+  case GNUNET_ATS_SOLVER_MLP:
+    solver_str = "mlp";
+    break;
+
+  case GNUNET_ATS_SOLVER_RIL:
+    solver_str = "ril";
+    break;
+
+  default:
+    GNUNET_break (0);
+    return NULL;
+    break;
+  }
+
+  sh = GNUNET_new (struct SolverHandle);
+  GNUNET_asprintf (&sh->plugin,
+                   "libgnunet_plugin_ats_%s",
+                   solver_str);
+  sh->addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
 
   /* setup environment */
   sh->env.cfg = e->cfg;
-  sh->env.stats = GNUNET_STATISTICS_create("ats", e->cfg);
+  sh->env.stats = GNUNET_STATISTICS_create ("ats", e->cfg);
   sh->env.addresses = sh->addresses;
   sh->env.bandwidth_changed_cb = &solver_bandwidth_changed_cb;
   sh->env.get_preferences = &get_preferences_cb;
@@ -3129,35 +3289,37 @@ GNUNET_ATS_solvers_solver_start(enum GNUNET_ATS_Solvers type)
   sh->env.network_count = GNUNET_NT_COUNT;
 
   /* start normalization */
-  GAS_normalization_start();
+  GAS_normalization_start ();
 
   /* load quotas */
-  if (GNUNET_NT_COUNT != GNUNET_ATS_solvers_load_quotas(e->cfg,
-                                                        sh->env.out_quota, sh->env.in_quota, GNUNET_NT_COUNT))
-    {
-      GNUNET_break(0);
-      GNUNET_free(sh->plugin);
-      GNUNET_free(sh);
-      end_now();
-      return NULL;
-    }
-
-  sh->sf = GNUNET_PLUGIN_load(sh->plugin, &sh->env);
+  if (GNUNET_NT_COUNT != GNUNET_ATS_solvers_load_quotas (e->cfg,
+                                                         sh->env.out_quota,
+                                                         sh->env.in_quota,
+                                                         GNUNET_NT_COUNT))
+  {
+    GNUNET_break (0);
+    GNUNET_free (sh->plugin);
+    GNUNET_free (sh);
+    end_now ();
+    return NULL;
+  }
+
+  sh->sf = GNUNET_PLUGIN_load (sh->plugin, &sh->env);
   if (NULL == sh->sf)
-    {
-      fprintf(stderr, "Failed to load solver `%s'\n", sh->plugin);
-      GNUNET_break(0);
-      GNUNET_free(sh->plugin);
-      GNUNET_free(sh);
-      end_now();
-      return NULL;
-    }
+  {
+    fprintf (stderr, "Failed to load solver `%s'\n", sh->plugin);
+    GNUNET_break (0);
+    GNUNET_free (sh->plugin);
+    GNUNET_free (sh);
+    end_now ();
+    return NULL;
+  }
   return sh;
 }
 
 
 static void
-done()
+done ()
 {
   struct TestPeer *cur;
   struct TestPeer *next;
@@ -3166,79 +3328,80 @@ done()
   struct TestAddress *next_a;
 
   /* Stop logging */
-  GNUNET_ATS_solver_logging_stop(l);
+  GNUNET_ATS_solver_logging_stop (l);
 
   /* Stop all preference generation */
-  GNUNET_ATS_solver_generate_preferences_stop_all();
+  GNUNET_ATS_solver_generate_preferences_stop_all ();
 
   /* Stop all property generation */
-  GNUNET_ATS_solver_generate_property_stop_all();
+  GNUNET_ATS_solver_generate_property_stop_all ();
 
   if (opt_print)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "== Printing log information \n");
-      GNUNET_ATS_solver_logging_eval(l);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "== Printing log information \n");
+    GNUNET_ATS_solver_logging_eval (l);
+  }
   if (opt_save)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "== Saving log information \n");
-      GNUNET_ATS_solver_logging_write_to_disk(l, e->log_append_time_stamp,
-                                              e->log_output_dir);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "== Saving log information \n");
+    GNUNET_ATS_solver_logging_write_to_disk (l, e->log_append_time_stamp,
+                                             e->log_output_dir);
+  }
 
   if (NULL != l)
-    {
-      GNUNET_ATS_solver_logging_free(l);
-      l = NULL;
-    }
+  {
+    GNUNET_ATS_solver_logging_free (l);
+    l = NULL;
+  }
 
   /* Clean up experiment */
   if (NULL != e)
-    {
-      GNUNET_ATS_solvers_experimentation_stop(e);
-      e = NULL;
-    }
+  {
+    GNUNET_ATS_solvers_experimentation_stop (e);
+    e = NULL;
+  }
 
   next = peer_head;
   while (NULL != (cur = next))
+  {
+    next = cur->next;
+    GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, cur);
+    next_a = cur->addr_head;
+    while (NULL != (cur_a = next_a))
     {
-      next = cur->next;
-      GNUNET_CONTAINER_DLL_remove(peer_head, peer_tail, cur);
-      next_a = cur->addr_head;
-      while (NULL != (cur_a = next_a))
-        {
-          next_a = cur_a->next;
-          GNUNET_CONTAINER_DLL_remove(cur->addr_head, cur->addr_tail, cur_a);
-          GNUNET_free(cur_a);
-        }
-      GNUNET_free(cur);
+      next_a = cur_a->next;
+      GNUNET_CONTAINER_DLL_remove (cur->addr_head, cur->addr_tail, cur_a);
+      GNUNET_free (cur_a);
     }
+    GNUNET_free (cur);
+  }
   if (NULL != sh)
-    {
-      GNUNET_ATS_solvers_solver_stop(sh);
-      sh = NULL;
-    }
+  {
+    GNUNET_ATS_solvers_solver_stop (sh);
+    sh = NULL;
+  }
 
   /* Shutdown */
-  end_now();
+  end_now ();
 }
 
 static void
-experiment_done_cb(struct Experiment *e, struct GNUNET_TIME_Relative duration, int success)
+experiment_done_cb (struct Experiment *e, struct GNUNET_TIME_Relative duration,
+                    int success)
 {
   if (GNUNET_OK == success)
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment done successful in %s\n",
-               GNUNET_STRINGS_relative_time_to_string(duration, GNUNET_YES));
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment done successful in %s\n",
+                GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment failed \n");
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment failed \n");
 
-  GNUNET_SCHEDULER_add_now(&done, NULL);
+  GNUNET_SCHEDULER_add_now (&done, NULL);
 }
 
 static void
-episode_done_cb(struct Episode *ep)
+episode_done_cb (struct Episode *ep)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Episode %u done\n", ep->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Episode %u done\n", ep->id);
 }
 
 
@@ -3247,62 +3410,62 @@ episode_done_cb(struct Episode *ep)
  * Do shutdown
  */
 static void
-end_now()
+end_now ()
 {
   if (NULL != e)
-    {
-      GNUNET_ATS_solvers_experimentation_stop(e);
-      e = NULL;
-    }
+  {
+    GNUNET_ATS_solvers_experimentation_stop (e);
+    e = NULL;
+  }
   if (NULL != sh)
-    {
-      GNUNET_ATS_solvers_solver_stop(sh);
-      sh = NULL;
-    }
+  {
+    GNUNET_ATS_solvers_solver_stop (sh);
+    sh = NULL;
+  }
 }
 
 static void
-run(void *cls, char * const *args, const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   enum GNUNET_ATS_Solvers solver;
   int c;
 
   if (NULL == opt_exp_file)
-    {
-      fprintf(stderr, "No experiment given ...\n");
-      res = 1;
-      end_now();
-      return;
-    }
+  {
+    fprintf (stderr, "No experiment given ...\n");
+    res = 1;
+    end_now ();
+    return;
+  }
 
   if (NULL == opt_solver)
-    {
-      fprintf(stderr, "No solver given ...\n");
-      res = 1;
-      end_now();
-      return;
-    }
+  {
+    fprintf (stderr, "No solver given ...\n");
+    res = 1;
+    end_now ();
+    return;
+  }
 
-  if (0 == strcmp(opt_solver, "mlp"))
-    {
-      solver = GNUNET_ATS_SOLVER_MLP;
-    }
-  else if (0 == strcmp(opt_solver, "proportional"))
-    {
-      solver = GNUNET_ATS_SOLVER_PROPORTIONAL;
-    }
-  else if (0 == strcmp(opt_solver, "ril"))
-    {
-      solver = GNUNET_ATS_SOLVER_RIL;
-    }
+  if (0 == strcmp (opt_solver, "mlp"))
+  {
+    solver = GNUNET_ATS_SOLVER_MLP;
+  }
+  else if (0 == strcmp (opt_solver, "proportional"))
+  {
+    solver = GNUNET_ATS_SOLVER_PROPORTIONAL;
+  }
+  else if (0 == strcmp (opt_solver, "ril"))
+  {
+    solver = GNUNET_ATS_SOLVER_RIL;
+  }
   else
-    {
-      fprintf(stderr, "No solver given ...");
-      res = 1;
-      end_now();
-      return;
-    }
+  {
+    fprintf (stderr, "No solver given ...");
+    res = 1;
+    end_now ();
+    return;
+  }
 
   for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
     default_properties[c] = DEFAULT_REL_QUALITY;
@@ -3311,35 +3474,35 @@ run(void *cls, char * const *args, const char *cfgfile,
     default_preferences[c] = DEFAULT_REL_PREFERENCE;
 
   /* load experiment */
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Loading experiment\n");
-  e = GNUNET_ATS_solvers_experimentation_load(opt_exp_file);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Loading experiment\n");
+  e = GNUNET_ATS_solvers_experimentation_load (opt_exp_file);
   if (NULL == e)
-    {
-      fprintf(stderr, "Failed to load experiment ...\n");
-      res = 1;
-      end_now();
-      return;
-    }
+  {
+    fprintf (stderr, "Failed to load experiment ...\n");
+    res = 1;
+    end_now ();
+    return;
+  }
 
   /* load solver */
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Loading solver\n");
-  sh = GNUNET_ATS_solvers_solver_start(solver);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Loading solver\n");
+  sh = GNUNET_ATS_solvers_solver_start (solver);
   if (NULL == sh)
-    {
-      fprintf(stderr, "Failed to start solver ...\n");
-      end_now();
-      res = 1;
-      return;
-    }
+  {
+    fprintf (stderr, "Failed to start solver ...\n");
+    end_now ();
+    res = 1;
+    return;
+  }
 
   /* start logging */
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Start logging \n");
-  l = GNUNET_ATS_solver_logging_start(e->log_freq);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Start logging \n");
+  l = GNUNET_ATS_solver_logging_start (e->log_freq);
 
   /* run experiment */
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Running experiment \n");
-  GNUNET_ATS_solvers_experimentation_run(e, episode_done_cb,
-                                         experiment_done_cb);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Running experiment \n");
+  GNUNET_ATS_solvers_experimentation_run (e, episode_done_cb,
+                                          experiment_done_cb);
 
   /* WAIT */
 }
@@ -3352,7 +3515,7 @@ run(void *cls, char * const *args, const char *cfgfile,
  * @param argv argument values
  */
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   opt_exp_file = NULL;
   opt_solver = NULL;
@@ -3361,40 +3524,39 @@ main(int argc, char *argv[])
 
   res = 0;
 
-  static struct GNUNET_GETOPT_CommandLineOption options[] =
-  {
-    GNUNET_GETOPT_option_string('s',
-                                "solver",
-                                gettext_noop("solver to use"),
-                                &opt_solver),
+  static struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_string ('s',
+                                 "solver",
+                                 gettext_noop ("solver to use"),
+                                 &opt_solver),
 
-    GNUNET_GETOPT_option_string('e',
-                                "experiment"
-                                gettext_noop("experiment to use"),
-                                &opt_exp_file),
+    GNUNET_GETOPT_option_string ('e',
+                                 "experiment"
+                                 gettext_noop ("experiment to use"),
+                                 &opt_exp_file),
 
-    GNUNET_GETOPT_option_verbose(&opt_verbose),
+    GNUNET_GETOPT_option_verbose (&opt_verbose),
 
-    GNUNET_GETOPT_option_flag('p',
-                              "print",
-                              gettext_noop("print logging"),
-                              &opt_print),
+    GNUNET_GETOPT_option_flag ('p',
+                               "print",
+                               gettext_noop ("print logging"),
+                               &opt_print),
 
-    GNUNET_GETOPT_option_flag('f',
-                              "file",
-                              gettext_noop("save logging to disk"),
-                              &opt_save),
+    GNUNET_GETOPT_option_flag ('f',
+                               "file",
+                               gettext_noop ("save logging to disk"),
+                               &opt_save),
 
-    GNUNET_GETOPT_option_flag('d',
-                              "dn",
-                              gettext_noop("disable normalization"),
-                              &opt_disable_normalization),
+    GNUNET_GETOPT_option_flag ('d',
+                               "dn",
+                               gettext_noop ("disable normalization"),
+                               &opt_disable_normalization),
 
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_PROGRAM_run(argc, argv, "gnunet-ats-solver-eval",
-                     NULL, options, &run, argv[0]);
+  GNUNET_PROGRAM_run (argc, argv, "gnunet-ats-solver-eval",
+                      NULL, options, &run, argv[0]);
 
   return res;
 }
diff --git a/src/ats/gnunet-ats-solver-eval.h b/src/ats/gnunet-ats-solver-eval.h
index e3afa02b1..7d14bf761 100644
--- a/src/ats/gnunet-ats-solver-eval.h
+++ b/src/ats/gnunet-ats-solver-eval.h
@@ -34,7 +34,8 @@
 #include "gnunet-service-ats_normalization.h"
 #include "test_ats_api_common.h"
 
-enum GeneratorType {
+enum GeneratorType
+{
   GNUNET_ATS_TEST_TG_LINEAR,
   GNUNET_ATS_TEST_TG_CONSTANT,
   GNUNET_ATS_TEST_TG_RANDOM,
@@ -42,7 +43,8 @@ enum GeneratorType {
 };
 
 
-enum OperationType {
+enum OperationType
+{
   SOLVER_OP_ADD_ADDRESS,
   SOLVER_OP_DEL_ADDRESS,
   SOLVER_OP_START_SET_PROPERTY,
@@ -53,7 +55,8 @@ enum OperationType {
   SOLVER_OP_STOP_REQUEST,
 };
 
-struct SolverHandle {
+struct SolverHandle
+{
   /**
    * Solver plugin name
    */
@@ -75,13 +78,15 @@ struct SolverHandle {
   struct GNUNET_CONTAINER_MultiPeerMap *addresses;
 };
 
-enum GNUNET_ATS_Solvers {
+enum GNUNET_ATS_Solvers
+{
   GNUNET_ATS_SOLVER_PROPORTIONAL,
   GNUNET_ATS_SOLVER_MLP,
   GNUNET_ATS_SOLVER_RIL,
 };
 
-struct LoggingFileHandle {
+struct LoggingFileHandle
+{
   /* DLL list for logging time steps */
   struct LoggingFileHandle *next;
   struct LoggingFileHandle *prev;
@@ -95,7 +100,8 @@ struct LoggingFileHandle {
   struct GNUNET_DISK_FileHandle *f_hd;
 };
 
-struct LoggingTimeStep {
+struct LoggingTimeStep
+{
   struct LoggingTimeStep *prev;
   struct LoggingTimeStep *next;
 
@@ -106,7 +112,8 @@ struct LoggingTimeStep {
   struct GNUNET_TIME_Relative delta;
 };
 
-struct LoggingPeer {
+struct LoggingPeer
+{
   struct LoggingPeer *prev;
   struct LoggingPeer *next;
 
@@ -120,7 +127,8 @@ struct LoggingPeer {
   struct LoggingAddress *addr_tail;
 };
 
-struct LoggingAddress {
+struct LoggingAddress
+{
   struct LoggingAddress *next;
   struct LoggingAddress *prev;
 
@@ -135,7 +143,8 @@ struct LoggingAddress {
 };
 
 
-struct TestPeer {
+struct TestPeer
+{
   struct TestPeer *prev;
   struct TestPeer *next;
 
@@ -155,7 +164,8 @@ struct TestPeer {
 };
 
 
-struct TestAddress {
+struct TestAddress
+{
   struct TestAddress *next;
   struct TestAddress *prev;
 
@@ -175,12 +185,16 @@ typedef void (*GNUNET_ATS_TESTING_EpisodeDoneCallback) (
   struct Episode *e);
 
 typedef void (*GNUNET_ATS_TESTING_ExperimentDoneCallback) (struct Experiment *e,
-                                                           struct GNUNET_TIME_Relative duration, int success);
+                                                           struct
+                                                           GNUNET_TIME_Relative
+                                                           duration, int
+                                                           success);
 
 /**
  * An operation in an experiment
  */
-struct GNUNET_ATS_TEST_Operation {
+struct GNUNET_ATS_TEST_Operation
+{
   struct GNUNET_ATS_TEST_Operation *next;
   struct GNUNET_ATS_TEST_Operation *prev;
 
@@ -206,7 +220,8 @@ struct GNUNET_ATS_TEST_Operation {
   // enum GNUNET_ATS_Property prop_type;
 };
 
-struct Episode {
+struct Episode
+{
   int id;
   struct Episode *next;
   struct GNUNET_TIME_Relative duration;
@@ -215,8 +230,9 @@ struct Episode {
   struct GNUNET_ATS_TEST_Operation *tail;
 };
 
-struct LoggingHandle {
-  struct GNUNET_SCHEDULER_Task * logging_task;
+struct LoggingHandle
+{
+  struct GNUNET_SCHEDULER_Task *logging_task;
   struct GNUNET_TIME_Relative log_freq;
 
   /* DLL list for logging time steps */
@@ -224,7 +240,8 @@ struct LoggingHandle {
   struct LoggingTimeStep *tail;
 };
 
-struct Experiment {
+struct Experiment
+{
   char *name;
   char *log_prefix;
   char *cfg_file;
@@ -240,15 +257,16 @@ struct Experiment {
 
   struct GNUNET_CONFIGURATION_Handle *cfg;
 
-  struct GNUNET_SCHEDULER_Task * experiment_timeout_task;
-  struct GNUNET_SCHEDULER_Task * episode_timeout_task;
+  struct GNUNET_SCHEDULER_Task *experiment_timeout_task;
+  struct GNUNET_SCHEDULER_Task *episode_timeout_task;
   struct Episode *cur;
 
   GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb;
   GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb;
 };
 
-struct PreferenceGenerator {
+struct PreferenceGenerator
+{
   struct PreferenceGenerator *prev;
   struct PreferenceGenerator *next;
 
@@ -265,8 +283,8 @@ struct PreferenceGenerator {
   struct GNUNET_TIME_Relative frequency;
   struct GNUNET_TIME_Relative feedback_frequency;
 
-  struct GNUNET_SCHEDULER_Task * set_task;
-  struct GNUNET_SCHEDULER_Task * feedback_task;
+  struct GNUNET_SCHEDULER_Task *set_task;
+  struct GNUNET_SCHEDULER_Task *feedback_task;
   struct GNUNET_TIME_Absolute next_ping_transmission;
   struct GNUNET_TIME_Absolute time_start;
 
@@ -289,7 +307,8 @@ struct PreferenceGenerator {
 };
 
 
-struct PropertyGenerator {
+struct PropertyGenerator
+{
   struct PropertyGenerator *prev;
   struct PropertyGenerator *next;
 
@@ -307,7 +326,7 @@ struct PropertyGenerator {
   struct GNUNET_TIME_Relative duration_period;
   struct GNUNET_TIME_Relative frequency;
 
-  struct GNUNET_SCHEDULER_Task * set_task;
+  struct GNUNET_SCHEDULER_Task *set_task;
   struct GNUNET_TIME_Absolute next_ping_transmission;
   struct GNUNET_TIME_Absolute time_start;
 };
diff --git a/src/ats/gnunet-service-ats-new.c b/src/ats/gnunet-service-ats-new.c
index 1061c28c2..f2ef92436 100644
--- a/src/ats/gnunet-service-ats-new.c
+++ b/src/ats/gnunet-service-ats-new.c
@@ -33,7 +33,8 @@
 /**
  * What type of client is this client?
  */
-enum ClientType {
+enum ClientType
+{
   /**
    * We don't know yet.
    */
@@ -59,7 +60,8 @@ struct Client;
 /**
  * Preferences expressed by a client are kept in a DLL per client.
  */
-struct ClientPreference {
+struct ClientPreference
+{
   /**
    * DLL pointer.
    */
@@ -90,7 +92,8 @@ struct ClientPreference {
 /**
  * Information about ongoing sessions of the transport client.
  */
-struct GNUNET_ATS_Session {
+struct GNUNET_ATS_Session
+{
   /**
    * Session data exposed to the plugin.
    */
@@ -116,7 +119,8 @@ struct GNUNET_ATS_Session {
 /**
  * Information we track per client.
  */
-struct Client {
+struct Client
+{
   /**
    * Type of the client, initially #CT_NONE.
    */
@@ -135,8 +139,10 @@ struct Client {
   /**
    * Details depending on @e type.
    */
-  union {
-    struct {
+  union
+  {
+    struct
+    {
       /**
        * Head of DLL of preferences expressed by this client.
        */
@@ -148,7 +154,8 @@ struct Client {
       struct ClientPreference *cp_tail;
     } application;
 
-    struct {
+    struct
+    {
       /**
        * Map from session IDs to `struct GNUNET_ATS_Session` objects.
        */
@@ -188,32 +195,32 @@ static struct Client *transport_client;
  * @param address address the transport should try
  */
 static void
-suggest_cb(void *cls,
-           const struct GNUNET_PeerIdentity *pid,
-           const char *address)
+suggest_cb (void *cls,
+            const struct GNUNET_PeerIdentity *pid,
+            const char *address)
 {
   struct GNUNET_MQ_Envelope *env;
-  size_t slen = strlen(address) + 1;
+  size_t slen = strlen (address) + 1;
   struct AddressSuggestionMessage *as;
 
   if (NULL == transport_client)
-    {
-      // FIXME: stats!
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Suggesting address `%s' of peer `%s'\n",
-             address,
-             GNUNET_i2s(pid));
-  env = GNUNET_MQ_msg_extra(as,
-                            slen,
-                            GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION);
+  {
+    // FIXME: stats!
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Suggesting address `%s' of peer `%s'\n",
+              address,
+              GNUNET_i2s (pid));
+  env = GNUNET_MQ_msg_extra (as,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION);
   as->peer = *pid;
-  memcpy(&as[1],
-         address,
-         slen);
-  GNUNET_MQ_send(transport_client->mq,
-                 env);
+  memcpy (&as[1],
+          address,
+          slen);
+  GNUNET_MQ_send (transport_client->mq,
+                  env);
 }
 
 
@@ -228,37 +235,37 @@ suggest_cb(void *cls,
  * @param bw_out suggested bandwidth for transmission
  */
 static void
-allocate_cb(void *cls,
-            struct GNUNET_ATS_Session *session,
-            const struct GNUNET_PeerIdentity *peer,
-            struct GNUNET_BANDWIDTH_Value32NBO bw_in,
-            struct GNUNET_BANDWIDTH_Value32NBO bw_out)
+allocate_cb (void *cls,
+             struct GNUNET_ATS_Session *session,
+             const struct GNUNET_PeerIdentity *peer,
+             struct GNUNET_BANDWIDTH_Value32NBO bw_in,
+             struct GNUNET_BANDWIDTH_Value32NBO bw_out)
 {
   struct GNUNET_MQ_Envelope *env;
   struct SessionAllocationMessage *sam;
 
-  (void)cls;
+  (void) cls;
   if ((NULL == transport_client) ||
       (session->client != transport_client))
-    {
-      /* transport must have just died and solver is addressing the
-         losses of sessions (possibly of previous transport), ignore! */
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Allocating %u/%u bytes for %p of peer `%s'\n",
-             ntohl(bw_in.value__),
-             ntohl(bw_out.value__),
-             session,
-             GNUNET_i2s(peer));
-  env = GNUNET_MQ_msg(sam,
-                      GNUNET_MESSAGE_TYPE_ATS_SESSION_ALLOCATION);
+  {
+    /* transport must have just died and solver is addressing the
+       losses of sessions (possibly of previous transport), ignore! */
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Allocating %u/%u bytes for %p of peer `%s'\n",
+              ntohl (bw_in.value__),
+              ntohl (bw_out.value__),
+              session,
+              GNUNET_i2s (peer));
+  env = GNUNET_MQ_msg (sam,
+                       GNUNET_MESSAGE_TYPE_ATS_SESSION_ALLOCATION);
   sam->session_id = session->session_id;
   sam->peer = *peer;
   sam->bandwidth_in = bw_in;
   sam->bandwidth_out = bw_out;
-  GNUNET_MQ_send(transport_client->mq,
-                 env);
+  GNUNET_MQ_send (transport_client->mq,
+                  env);
 }
 
 
@@ -269,18 +276,19 @@ allocate_cb(void *cls,
  * @param prop[out] in HBO
  */
 static void
-prop_ntoh(const struct PropertiesNBO *properties,
-          struct GNUNET_ATS_Properties *prop)
+prop_ntoh (const struct PropertiesNBO *properties,
+           struct GNUNET_ATS_Properties *prop)
 {
-  prop->delay = GNUNET_TIME_relative_ntoh(properties->delay);
-  prop->goodput_out = ntohl(properties->goodput_out);
-  prop->goodput_in = ntohl(properties->goodput_in);
-  prop->utilization_out = ntohl(properties->utilization_out);
-  prop->utilization_in = ntohl(properties->utilization_in);
-  prop->distance = ntohl(properties->distance);
-  prop->mtu = ntohl(properties->mtu);
-  prop->nt = (enum GNUNET_NetworkType)ntohl(properties->nt);
-  prop->cc = (enum GNUNET_TRANSPORT_CommunicatorCharacteristics)ntohl(properties->cc);
+  prop->delay = GNUNET_TIME_relative_ntoh (properties->delay);
+  prop->goodput_out = ntohl (properties->goodput_out);
+  prop->goodput_in = ntohl (properties->goodput_in);
+  prop->utilization_out = ntohl (properties->utilization_out);
+  prop->utilization_in = ntohl (properties->utilization_in);
+  prop->distance = ntohl (properties->distance);
+  prop->mtu = ntohl (properties->mtu);
+  prop->nt = (enum GNUNET_NetworkType) ntohl (properties->nt);
+  prop->cc = (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (
+    properties->cc);
 }
 
 
@@ -291,8 +299,8 @@ prop_ntoh(const struct PropertiesNBO *properties,
  * @param msg the start message
  */
 static void
-handle_suggest(void *cls,
-               const struct ExpressPreferenceMessage *msg)
+handle_suggest (void *cls,
+                const struct ExpressPreferenceMessage *msg)
 {
   struct Client *c = cls;
   struct ClientPreference *cp;
@@ -300,27 +308,27 @@ handle_suggest(void *cls,
   if (CT_NONE == c->type)
     c->type = CT_APPLICATION;
   if (CT_APPLICATION != c->type)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Client suggested we talk to %s with preference %d at rate %u\n",
-             GNUNET_i2s(&msg->peer),
-             (int)ntohl(msg->pk),
-             (int)ntohl(msg->bw.value__));
-  cp = GNUNET_new(struct ClientPreference);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client suggested we talk to %s with preference %d at rate %u\n",
+              GNUNET_i2s (&msg->peer),
+              (int) ntohl (msg->pk),
+              (int) ntohl (msg->bw.value__));
+  cp = GNUNET_new (struct ClientPreference);
   cp->client = c;
   cp->pref.peer = msg->peer;
   cp->pref.bw = msg->bw;
-  cp->pref.pk = (enum GNUNET_MQ_PreferenceKind)ntohl(msg->pk);
-  cp->ph = plugin->preference_add(plugin->cls,
-                                  &cp->pref);
-  GNUNET_CONTAINER_DLL_insert(c->details.application.cp_head,
-                              c->details.application.cp_tail,
-                              cp);
-  GNUNET_SERVICE_client_continue(c->client);
+  cp->pref.pk = (enum GNUNET_MQ_PreferenceKind) ntohl (msg->pk);
+  cp->ph = plugin->preference_add (plugin->cls,
+                                   &cp->pref);
+  GNUNET_CONTAINER_DLL_insert (c->details.application.cp_head,
+                               c->details.application.cp_tail,
+                               cp);
+  GNUNET_SERVICE_client_continue (c->client);
 }
 
 
@@ -331,8 +339,8 @@ handle_suggest(void *cls,
  * @param msg the start message
  */
 static void
-handle_suggest_cancel(void *cls,
-                      const struct ExpressPreferenceMessage *msg)
+handle_suggest_cancel (void *cls,
+                       const struct ExpressPreferenceMessage *msg)
 {
   struct Client *c = cls;
   struct ClientPreference *cp;
@@ -340,33 +348,33 @@ handle_suggest_cancel(void *cls,
   if (CT_NONE == c->type)
     c->type = CT_APPLICATION;
   if (CT_APPLICATION != c->type)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
   for (cp = c->details.application.cp_head;
        NULL != cp;
        cp = cp->next)
-    if ((cp->pref.pk == (enum GNUNET_MQ_PreferenceKind)ntohl(msg->pk)) &&
+    if ((cp->pref.pk == (enum GNUNET_MQ_PreferenceKind) ntohl (msg->pk)) &&
         (cp->pref.bw.value__ == msg->bw.value__) &&
-        (0 == GNUNET_memcmp(&cp->pref.peer,
-                            &msg->peer)))
+        (0 == GNUNET_memcmp (&cp->pref.peer,
+                             &msg->peer)))
       break;
   if (NULL == cp)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
-  plugin->preference_del(plugin->cls,
-                         cp->ph,
-                         &cp->pref);
-  GNUNET_CONTAINER_DLL_remove(c->details.application.cp_head,
-                              c->details.application.cp_tail,
-                              cp);
-  GNUNET_free(cp);
-  GNUNET_SERVICE_client_continue(c->client);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  plugin->preference_del (plugin->cls,
+                          cp->ph,
+                          &cp->pref);
+  GNUNET_CONTAINER_DLL_remove (c->details.application.cp_head,
+                               c->details.application.cp_tail,
+                               cp);
+  GNUNET_free (cp);
+  GNUNET_SERVICE_client_continue (c->client);
 }
 
 
@@ -377,27 +385,27 @@ handle_suggest_cancel(void *cls,
  * @param message the request message
  */
 static void
-handle_start(void *cls,
-             const struct GNUNET_MessageHeader *hdr)
+handle_start (void *cls,
+              const struct GNUNET_MessageHeader *hdr)
 {
   struct Client *c = cls;
 
   if (CT_NONE != c->type)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
   c->type = CT_TRANSPORT;
   c->details.transport.sessions
-    = GNUNET_CONTAINER_multihashmap32_create(128);
+    = GNUNET_CONTAINER_multihashmap32_create (128);
   if (NULL != transport_client)
-    {
-      GNUNET_SERVICE_client_drop(transport_client->client);
-      transport_client = NULL;
-    }
+  {
+    GNUNET_SERVICE_client_drop (transport_client->client);
+    transport_client = NULL;
+  }
   transport_client = c;
-  GNUNET_SERVICE_client_continue(c->client);
+  GNUNET_SERVICE_client_continue (c->client);
 }
 
 
@@ -410,17 +418,17 @@ handle_start(void *cls,
  * @return #GNUNET_OK if @a message is well-formed
  */
 static int
-check_session_add(void *cls,
-                  const struct SessionAddMessage *message)
+check_session_add (void *cls,
+                   const struct SessionAddMessage *message)
 {
   struct Client *c = cls;
 
-  GNUNET_MQ_check_zero_termination(message);
+  GNUNET_MQ_check_zero_termination (message);
   if (CT_TRANSPORT != c->type)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -432,45 +440,46 @@ check_session_add(void *cls,
  * @param message the request message
  */
 static void
-handle_session_add(void *cls,
-                   const struct SessionAddMessage *message)
+handle_session_add (void *cls,
+                    const struct SessionAddMessage *message)
 {
   struct Client *c = cls;
-  const char *address = (const char *)&message[1];
+  const char *address = (const char *) &message[1];
   struct GNUNET_ATS_Session *session;
   int inbound_only = (GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY ==
-                      ntohs(message->header.type));
+                      ntohs (message->header.type));
 
-  session = GNUNET_CONTAINER_multihashmap32_get(c->details.transport.sessions,
-                                                message->session_id);
+  session = GNUNET_CONTAINER_multihashmap32_get (c->details.transport.sessions,
+                                                 message->session_id);
   if (NULL != session)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
-  session = GNUNET_new(struct GNUNET_ATS_Session);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  session = GNUNET_new (struct GNUNET_ATS_Session);
   session->data.session = session;
   session->client = c;
   session->session_id = message->session_id;
   session->data.peer = message->peer;
-  prop_ntoh(&message->properties,
-            &session->data.prop);
+  prop_ntoh (&message->properties,
+             &session->data.prop);
   session->data.inbound_only = inbound_only;
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap32_put(c->details.transport.sessions,
-                                                    message->session_id,
-                                                    session,
-                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  session->sh = plugin->session_add(plugin->cls,
-                                    &session->data,
-                                    address);
-  GNUNET_assert(NULL != session->sh);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Transport has new session %p to %s\n",
-             session,
-             GNUNET_i2s(&message->peer));
-  GNUNET_SERVICE_client_continue(c->client);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap32_put (
+                   c->details.transport.sessions,
+                   message->session_id,
+                   session,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  session->sh = plugin->session_add (plugin->cls,
+                                     &session->data,
+                                     address);
+  GNUNET_assert (NULL != session->sh);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transport has new session %p to %s\n",
+              session,
+              GNUNET_i2s (&message->peer));
+  GNUNET_SERVICE_client_continue (c->client);
 }
 
 
@@ -481,32 +490,32 @@ handle_session_add(void *cls,
  * @param msg the request message
  */
 static void
-handle_session_update(void *cls,
-                      const struct SessionUpdateMessage *msg)
+handle_session_update (void *cls,
+                       const struct SessionUpdateMessage *msg)
 {
   struct Client *c = cls;
   struct GNUNET_ATS_Session *session;
 
   if (CT_TRANSPORT != c->type)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
-  session = GNUNET_CONTAINER_multihashmap32_get(c->details.transport.sessions,
-                                                msg->session_id);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  session = GNUNET_CONTAINER_multihashmap32_get (c->details.transport.sessions,
+                                                 msg->session_id);
   if (NULL == session)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
-  prop_ntoh(&msg->properties,
-            &session->data.prop);
-  plugin->session_update(plugin->cls,
-                         session->sh,
-                         &session->data);
-  GNUNET_SERVICE_client_continue(c->client);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  prop_ntoh (&msg->properties,
+             &session->data.prop);
+  plugin->session_update (plugin->cls,
+                          session->sh,
+                          &session->data);
+  GNUNET_SERVICE_client_continue (c->client);
 }
 
 
@@ -517,41 +526,42 @@ handle_session_update(void *cls,
  * @param message the request message
  */
 static void
-handle_session_del(void *cls,
-                   const struct SessionDelMessage *message)
+handle_session_del (void *cls,
+                    const struct SessionDelMessage *message)
 {
   struct Client *c = cls;
   struct GNUNET_ATS_Session *session;
 
   if (CT_TRANSPORT != c->type)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
-  session = GNUNET_CONTAINER_multihashmap32_get(c->details.transport.sessions,
-                                                message->session_id);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  session = GNUNET_CONTAINER_multihashmap32_get (c->details.transport.sessions,
+                                                 message->session_id);
   if (NULL == session)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(c->client);
-      return;
-    }
-  GNUNET_assert(NULL != session->sh);
-  plugin->session_del(plugin->cls,
-                      session->sh,
-                      &session->data);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  GNUNET_assert (NULL != session->sh);
+  plugin->session_del (plugin->cls,
+                       session->sh,
+                       &session->data);
   session->sh = NULL;
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap32_remove(c->details.transport.sessions,
-                                                       session->session_id,
-                                                       session));
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Transport lost session %p to %s\n",
-             session,
-             GNUNET_i2s(&session->data.peer));
-  GNUNET_free(session);
-  GNUNET_SERVICE_client_continue(c->client);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap32_remove (
+                   c->details.transport.sessions,
+                   session->session_id,
+                   session));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transport lost session %p to %s\n",
+              session,
+              GNUNET_i2s (&session->data.peer));
+  GNUNET_free (session);
+  GNUNET_SERVICE_client_continue (c->client);
 }
 
 
@@ -565,11 +575,11 @@ handle_session_del(void *cls,
  * @return @a client
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *client,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
 {
-  struct Client *c = GNUNET_new(struct Client);
+  struct Client *c = GNUNET_new (struct Client);
 
   c->client = client;
   c->mq = mq;
@@ -586,21 +596,21 @@ client_connect_cb(void *cls,
  * @param value a `struct GNUNET_ATS_Session`
  */
 static int
-free_session(void *cls,
-             uint32_t key,
-             void *value)
+free_session (void *cls,
+              uint32_t key,
+              void *value)
 {
   struct Client *c = cls;
   struct GNUNET_ATS_Session *session = value;
 
-  (void)key;
-  GNUNET_assert(c == session->client);
-  GNUNET_assert(NULL != session->sh);
-  plugin->session_del(plugin->cls,
-                      session->sh,
-                      &session->data);
+  (void) key;
+  GNUNET_assert (c == session->client);
+  GNUNET_assert (NULL != session->sh);
+  plugin->session_del (plugin->cls,
+                       session->sh,
+                       &session->data);
   session->sh = NULL;
-  GNUNET_free(session);
+  GNUNET_free (session);
   return GNUNET_OK;
 }
 
@@ -614,44 +624,44 @@ free_session(void *cls,
  * @param app_ctx our `struct Client`
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *client,
-                     void *app_ctx)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
 {
   struct Client *c = app_ctx;
 
-  (void)cls;
-  GNUNET_assert(c->client == client);
+  (void) cls;
+  GNUNET_assert (c->client == client);
   switch (c->type)
+  {
+  case CT_NONE:
+    break;
+
+  case CT_APPLICATION:
+    for (struct ClientPreference *cp = c->details.application.cp_head;
+         NULL != cp;
+         cp = c->details.application.cp_head)
     {
-    case CT_NONE:
-      break;
-
-    case CT_APPLICATION:
-      for (struct ClientPreference *cp = c->details.application.cp_head;
-           NULL != cp;
-           cp = c->details.application.cp_head)
-        {
-          plugin->preference_del(plugin->cls,
-                                 cp->ph,
-                                 &cp->pref);
-          GNUNET_CONTAINER_DLL_remove(c->details.application.cp_head,
-                                      c->details.application.cp_tail,
-                                      cp);
-          GNUNET_free(cp);
-        }
-      break;
-
-    case CT_TRANSPORT:
-      if (transport_client == c)
-        transport_client = NULL;
-      GNUNET_CONTAINER_multihashmap32_iterate(c->details.transport.sessions,
-                                              &free_session,
-                                              c);
-      GNUNET_CONTAINER_multihashmap32_destroy(c->details.transport.sessions);
-      break;
+      plugin->preference_del (plugin->cls,
+                              cp->ph,
+                              &cp->pref);
+      GNUNET_CONTAINER_DLL_remove (c->details.application.cp_head,
+                                   c->details.application.cp_tail,
+                                   cp);
+      GNUNET_free (cp);
     }
-  GNUNET_free(c);
+    break;
+
+  case CT_TRANSPORT:
+    if (transport_client == c)
+      transport_client = NULL;
+    GNUNET_CONTAINER_multihashmap32_iterate (c->details.transport.sessions,
+                                             &free_session,
+                                             c);
+    GNUNET_CONTAINER_multihashmap32_destroy (c->details.transport.sessions);
+    break;
+  }
+  GNUNET_free (c);
 }
 
 
@@ -661,26 +671,26 @@ client_disconnect_cb(void *cls,
  * @param cls unused
  */
 static void
-final_cleanup(void *cls)
+final_cleanup (void *cls)
 {
-  (void)cls;
+  (void) cls;
   if (NULL != stats)
-    {
-      GNUNET_STATISTICS_destroy(stats,
-                                GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats,
+                               GNUNET_NO);
+    stats = NULL;
+  }
   if (NULL != plugin)
-    {
-      GNUNET_PLUGIN_unload(plugin_name,
-                           plugin);
-      plugin = NULL;
-    }
+  {
+    GNUNET_PLUGIN_unload (plugin_name,
+                          plugin);
+    plugin = NULL;
+  }
   if (NULL != plugin_name)
-    {
-      GNUNET_free(plugin_name);
-      plugin_name = NULL;
-    }
+  {
+    GNUNET_free (plugin_name);
+    plugin_name = NULL;
+  }
 }
 
 
@@ -690,13 +700,13 @@ final_cleanup(void *cls)
  * @param cls unused
  */
 static void
-cleanup_task(void *cls)
+cleanup_task (void *cls)
 {
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "ATS shutdown initiated\n");
-  GNUNET_SCHEDULER_add_now(&final_cleanup,
-                           NULL);
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ATS shutdown initiated\n");
+  GNUNET_SCHEDULER_add_now (&final_cleanup,
+                            NULL);
 }
 
 
@@ -708,45 +718,45 @@ cleanup_task(void *cls)
  * @param service the initialized service
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_SERVICE_Handle *service)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_SERVICE_Handle *service)
 {
   static struct GNUNET_ATS_PluginEnvironment env;
   char *solver;
 
-  stats = GNUNET_STATISTICS_create("ats",
-                                   cfg);
+  stats = GNUNET_STATISTICS_create ("ats",
+                                    cfg);
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string(cfg,
-                                            "ats",
-                                            "SOLVER",
-                                            &solver))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "No ATS solver configured, using 'simple' approach\n");
-      solver = GNUNET_strdup("simple");
-    }
-  GNUNET_SCHEDULER_add_shutdown(&cleanup_task,
-                                NULL);
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "ats",
+                                             "SOLVER",
+                                             &solver))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "No ATS solver configured, using 'simple' approach\n");
+    solver = GNUNET_strdup ("simple");
+  }
+  GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
+                                 NULL);
   env.cls = NULL;
   env.cfg = cfg;
   env.stats = stats;
   env.suggest_cb = &suggest_cb;
   env.allocate_cb = &allocate_cb;
-  GNUNET_asprintf(&plugin_name,
-                  "libgnunet_plugin_ats2_%s",
-                  solver);
-  GNUNET_free(solver);
-  if (NULL == (plugin = GNUNET_PLUGIN_load(plugin_name,
-                                           &env)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to initialize solver `%s'!\n"),
-                 plugin_name);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  GNUNET_asprintf (&plugin_name,
+                   "libgnunet_plugin_ats2_%s",
+                   solver);
+  GNUNET_free (solver);
+  if (NULL == (plugin = GNUNET_PLUGIN_load (plugin_name,
+                                            &env)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to initialize solver `%s'!\n"),
+                plugin_name);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 }
 
 
@@ -760,35 +770,35 @@ GNUNET_SERVICE_MAIN
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_fixed_size(suggest,
-                          GNUNET_MESSAGE_TYPE_ATS_SUGGEST,
-                          struct ExpressPreferenceMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(suggest_cancel,
-                          GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL,
-                          struct ExpressPreferenceMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(start,
-                          GNUNET_MESSAGE_TYPE_ATS_START,
-                          struct GNUNET_MessageHeader,
-                          NULL),
-  GNUNET_MQ_hd_var_size(session_add,
-                        GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD,
-                        struct SessionAddMessage,
-                        NULL),
-  GNUNET_MQ_hd_var_size(session_add,
-                        GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY,
-                        struct SessionAddMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(session_update,
-                          GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE,
-                          struct SessionUpdateMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(session_del,
-                          GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL,
-                          struct SessionDelMessage,
-                          NULL),
-  GNUNET_MQ_handler_end());
+  GNUNET_MQ_hd_fixed_size (suggest,
+                           GNUNET_MESSAGE_TYPE_ATS_SUGGEST,
+                           struct ExpressPreferenceMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (suggest_cancel,
+                           GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL,
+                           struct ExpressPreferenceMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (start,
+                           GNUNET_MESSAGE_TYPE_ATS_START,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_var_size (session_add,
+                         GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD,
+                         struct SessionAddMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (session_add,
+                         GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY,
+                         struct SessionAddMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (session_update,
+                           GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE,
+                           struct SessionUpdateMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (session_del,
+                           GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL,
+                           struct SessionDelMessage,
+                           NULL),
+  GNUNET_MQ_handler_end ());
 
 
 /* end of gnunet-service-ats.c */
diff --git a/src/ats/gnunet-service-ats.c b/src/ats/gnunet-service-ats.c
index d9bb71c2b..fbef6f166 100644
--- a/src/ats/gnunet-service-ats.c
+++ b/src/ats/gnunet-service-ats.c
@@ -50,47 +50,47 @@ struct GNUNET_STATISTICS_Handle *GSA_stats;
  * @param msg the start message
  */
 static void
-handle_ats_start(void *cls,
-                 const struct ClientStartMessage *msg)
+handle_ats_start (void *cls,
+                  const struct ClientStartMessage *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   enum StartFlag flag;
 
-  flag = ntohl(msg->start_flag);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received ATS_START (%d) message\n",
-             (int)flag);
+  flag = ntohl (msg->start_flag);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ATS_START (%d) message\n",
+              (int) flag);
   switch (flag)
+  {
+  case START_FLAG_SCHEDULING:
+    if (GNUNET_OK !=
+        GAS_scheduling_add_client (client))
     {
-    case START_FLAG_SCHEDULING:
-      if (GNUNET_OK !=
-          GAS_scheduling_add_client(client))
-        {
-          GNUNET_SERVICE_client_drop(client);
-          return;
-        }
-      break;
-
-    case START_FLAG_PERFORMANCE_WITH_PIC:
-      GAS_performance_add_client(client,
-                                 flag);
-      break;
-
-    case START_FLAG_PERFORMANCE_NO_PIC:
-      GAS_performance_add_client(client,
-                                 flag);
-      break;
-
-    case START_FLAG_CONNECTION_SUGGESTION:
-      /* This client won't receive messages from us, no need to 'add' */
-      break;
-
-    default:
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(client);
+      GNUNET_SERVICE_client_drop (client);
       return;
     }
-  GNUNET_SERVICE_client_continue(client);
+    break;
+
+  case START_FLAG_PERFORMANCE_WITH_PIC:
+    GAS_performance_add_client (client,
+                                flag);
+    break;
+
+  case START_FLAG_PERFORMANCE_NO_PIC:
+    GAS_performance_add_client (client,
+                                flag);
+    break;
+
+  case START_FLAG_CONNECTION_SUGGESTION:
+    /* This client won't receive messages from us, no need to 'add' */
+    break;
+
+  default:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -102,14 +102,14 @@ handle_ats_start(void *cls,
  * @param message the request message
  */
 static void
-handle_reservation_request(void *cls,
-                           const struct ReservationRequestMessage *message)
+handle_reservation_request (void *cls,
+                            const struct ReservationRequestMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_reservation_request(client,
-                                 message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_reservation_request (client,
+                                  message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -121,23 +121,23 @@ handle_reservation_request(void *cls,
  * @return #GNUNET_OK if @a message is well-formed
  */
 static int
-check_feedback(void *cls,
-               const struct FeedbackPreferenceMessage *message)
+check_feedback (void *cls,
+                const struct FeedbackPreferenceMessage *message)
 {
   uint16_t msize;
   uint32_t nump;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received PREFERENCE_FEEDBACK message\n");
-  msize = ntohs(message->header.size);
-  nump = ntohl(message->num_feedback);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received PREFERENCE_FEEDBACK message\n");
+  msize = ntohs (message->header.size);
+  nump = ntohl (message->num_feedback);
   if (msize !=
-      sizeof(struct FeedbackPreferenceMessage) +
-      nump * sizeof(struct PreferenceInformation))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+      sizeof(struct FeedbackPreferenceMessage)
+      + nump * sizeof(struct PreferenceInformation))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -149,42 +149,43 @@ check_feedback(void *cls,
  * @param msg the request message
  */
 static void
-handle_feedback(void *cls,
-                const struct FeedbackPreferenceMessage *msg)
+handle_feedback (void *cls,
+                 const struct FeedbackPreferenceMessage *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   const struct PreferenceInformation *pi;
   uint32_t nump;
 
-  nump = ntohl(msg->num_feedback);
+  nump = ntohl (msg->num_feedback);
   if (GNUNET_NO ==
-      GNUNET_CONTAINER_multipeermap_contains(GSA_addresses,
-                                             &msg->peer))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Received PREFERENCE FEEDBACK for unknown peer `%s'\n",
-                 GNUNET_i2s(&msg->peer));
-      GNUNET_SERVICE_client_continue(client);
-      return;
-    }
+      GNUNET_CONTAINER_multipeermap_contains (GSA_addresses,
+                                              &msg->peer))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Received PREFERENCE FEEDBACK for unknown peer `%s'\n",
+                GNUNET_i2s (&msg->peer));
+    GNUNET_SERVICE_client_continue (client);
+    return;
+  }
 
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# preference feedbacks requests processed",
-                           1,
-                           GNUNET_NO);
-  pi = (const struct PreferenceInformation *)&msg[1];
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# preference feedbacks requests processed",
+                            1,
+                            GNUNET_NO);
+  pi = (const struct PreferenceInformation *) &msg[1];
   for (uint32_t i = 0; i < nump; i++)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Received PREFERENCE FEEDBACK for peer `%s'\n",
-                 GNUNET_i2s(&msg->peer));
-      GAS_plugin_notify_feedback(client,
-                                 &msg->peer,
-                                 GNUNET_TIME_relative_ntoh(msg->scope),
-                                 (enum GNUNET_ATS_PreferenceKind)ntohl(pi[i].preference_kind),
-                                 pi[i].preference_value);
-    }
-  GNUNET_SERVICE_client_continue(client);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received PREFERENCE FEEDBACK for peer `%s'\n",
+                GNUNET_i2s (&msg->peer));
+    GAS_plugin_notify_feedback (client,
+                                &msg->peer,
+                                GNUNET_TIME_relative_ntoh (msg->scope),
+                                (enum GNUNET_ATS_PreferenceKind) ntohl (
+                                  pi[i].preference_kind),
+                                pi[i].preference_value);
+  }
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -195,14 +196,14 @@ handle_feedback(void *cls,
  * @param message the request message
  */
 static void
-handle_request_address_list(void *cls,
-                            const struct AddressListRequestMessage *message)
+handle_request_address_list (void *cls,
+                             const struct AddressListRequestMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_request_address_list(client,
-                                  message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_request_address_list (client,
+                                   message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -213,14 +214,14 @@ handle_request_address_list(void *cls,
  * @param message the request message
  */
 static void
-handle_request_address(void *cls,
-                       const struct RequestAddressMessage * message)
+handle_request_address (void *cls,
+                        const struct RequestAddressMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_request_address(client,
-                             message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_request_address (client,
+                              message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -231,14 +232,14 @@ handle_request_address(void *cls,
  * @param message the request message
  */
 static void
-handle_request_address_cancel(void *cls,
-                              const struct RequestAddressMessage *message)
+handle_request_address_cancel (void *cls,
+                               const struct RequestAddressMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_request_address_cancel(client,
-                                    message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_request_address_cancel (client,
+                                     message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -249,8 +250,8 @@ handle_request_address_cancel(void *cls,
  * @param m the request message
  */
 static int
-check_address_add(void *cls,
-                  const struct AddressAddMessage *m)
+check_address_add (void *cls,
+                   const struct AddressAddMessage *m)
 {
   const char *address;
   const char *plugin_name;
@@ -258,23 +259,23 @@ check_address_add(void *cls,
   uint16_t plugin_name_length;
   uint16_t size;
 
-  size = ntohs(m->header.size);
-  address_length = ntohs(m->address_length);
-  plugin_name_length = ntohs(m->plugin_name_length);
-  address = (const char *)&m[1];
+  size = ntohs (m->header.size);
+  address_length = ntohs (m->address_length);
+  plugin_name_length = ntohs (m->plugin_name_length);
+  address = (const char *) &m[1];
   if (plugin_name_length != 0)
     plugin_name = &address[address_length];
   else
     plugin_name = "";
 
-  if ((address_length + plugin_name_length +
-       sizeof(struct AddressAddMessage) != size) ||
+  if ((address_length + plugin_name_length
+       + sizeof(struct AddressAddMessage) != size) ||
       ((plugin_name_length > 0) &&
        (plugin_name[plugin_name_length - 1] != '\0')))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -286,13 +287,13 @@ check_address_add(void *cls,
  * @param message the request message
  */
 static void
-handle_address_add(void *cls,
-                   const struct AddressAddMessage *message)
+handle_address_add (void *cls,
+                    const struct AddressAddMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_address_add(message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_address_add (message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -303,13 +304,13 @@ handle_address_add(void *cls,
  * @param message the request message
  */
 static void
-handle_address_update(void *cls,
-                      const struct AddressUpdateMessage *message)
+handle_address_update (void *cls,
+                       const struct AddressUpdateMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_address_update(message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_address_update (message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -320,13 +321,13 @@ handle_address_update(void *cls,
  * @param message the request message
  */
 static void
-handle_address_destroyed(void *cls,
-                         const struct AddressDestroyedMessage *message)
+handle_address_destroyed (void *cls,
+                          const struct AddressDestroyedMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_address_destroyed(message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_address_destroyed (message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -338,22 +339,22 @@ handle_address_destroyed(void *cls,
  * @return #GNUNET_OK if @a message is well-formed
  */
 static int
-check_preference_change(void *cls,
-                        const struct ChangePreferenceMessage *message)
+check_preference_change (void *cls,
+                         const struct ChangePreferenceMessage *message)
 {
   uint16_t msize;
   uint32_t nump;
 
-  msize = ntohs(message->header.size);
-  nump = ntohl(message->num_preferences);
+  msize = ntohs (message->header.size);
+  nump = ntohl (message->num_preferences);
   if ((msize !=
-       sizeof(struct ChangePreferenceMessage) +
-       nump * sizeof(struct PreferenceInformation)) ||
+       sizeof(struct ChangePreferenceMessage)
+       + nump * sizeof(struct PreferenceInformation)) ||
       (UINT16_MAX / sizeof(struct PreferenceInformation) < nump))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -365,14 +366,14 @@ check_preference_change(void *cls,
  * @param message the request message
  */
 static void
-handle_preference_change(void *cls,
-                         const struct ChangePreferenceMessage *message)
+handle_preference_change (void *cls,
+                          const struct ChangePreferenceMessage *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GAS_handle_preference_change(client,
-                               message);
-  GNUNET_SERVICE_client_continue(client);
+  GAS_handle_preference_change (client,
+                                message);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -386,9 +387,9 @@ handle_preference_change(void *cls,
  * @return @a client
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *client,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
 {
   return client;
 }
@@ -403,15 +404,15 @@ client_connect_cb(void *cls,
  * @param app_ctx
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *client,
-                     void *app_ctx)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
 {
   if (NULL == client)
     return;
-  GAS_scheduling_remove_client(client);
-  GAS_connectivity_remove_client(client);
-  GAS_preference_client_disconnect(client);
+  GAS_scheduling_remove_client (client);
+  GAS_connectivity_remove_client (client);
+  GAS_preference_client_disconnect (client);
 }
 
 
@@ -421,22 +422,22 @@ client_disconnect_cb(void *cls,
  * @param cls unused
  */
 static void
-cleanup_task(void *cls)
+cleanup_task (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "ATS shutdown initiated\n");
-  GAS_connectivity_done();
-  GAS_addresses_done();
-  GAS_plugin_done();
-  GAS_normalization_stop();
-  GAS_performance_done();
-  GAS_preference_done();
-  GAS_reservations_done();
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ATS shutdown initiated\n");
+  GAS_connectivity_done ();
+  GAS_addresses_done ();
+  GAS_plugin_done ();
+  GAS_normalization_stop ();
+  GAS_performance_done ();
+  GAS_preference_done ();
+  GAS_reservations_done ();
   if (NULL != GSA_stats)
-    {
-      GNUNET_STATISTICS_destroy(GSA_stats, GNUNET_NO);
-      GSA_stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (GSA_stats, GNUNET_NO);
+    GSA_stats = NULL;
+  }
 }
 
 
@@ -448,37 +449,37 @@ cleanup_task(void *cls)
  * @param service the initialized service
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_SERVICE_Handle *service)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_SERVICE_Handle *service)
 {
-  GSA_stats = GNUNET_STATISTICS_create("ats",
-                                       cfg);
-  GAS_reservations_init();
-  GAS_connectivity_init();
-  GAS_preference_init();
-  GAS_normalization_start();
-  GAS_addresses_init();
+  GSA_stats = GNUNET_STATISTICS_create ("ats",
+                                        cfg);
+  GAS_reservations_init ();
+  GAS_connectivity_init ();
+  GAS_preference_init ();
+  GAS_normalization_start ();
+  GAS_addresses_init ();
   if (GNUNET_OK !=
-      GAS_plugin_init(cfg))
+      GAS_plugin_init (cfg))
+  {
+    GNUNET_break (0);
+    GAS_addresses_done ();
+    GAS_normalization_stop ();
+    GAS_reservations_done ();
+    GAS_connectivity_done ();
+    GAS_preference_done ();
+    if (NULL != GSA_stats)
     {
-      GNUNET_break(0);
-      GAS_addresses_done();
-      GAS_normalization_stop();
-      GAS_reservations_done();
-      GAS_connectivity_done();
-      GAS_preference_done();
-      if (NULL != GSA_stats)
-        {
-          GNUNET_STATISTICS_destroy(GSA_stats,
-                                    GNUNET_NO);
-          GSA_stats = NULL;
-        }
-      return;
+      GNUNET_STATISTICS_destroy (GSA_stats,
+                                 GNUNET_NO);
+      GSA_stats = NULL;
     }
-  GAS_performance_init();
-  GNUNET_SCHEDULER_add_shutdown(&cleanup_task,
-                                NULL);
+    return;
+  }
+  GAS_performance_init ();
+  GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
+                                 NULL);
 }
 
 
@@ -492,47 +493,47 @@ GNUNET_SERVICE_MAIN
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_fixed_size(ats_start,
-                          GNUNET_MESSAGE_TYPE_ATS_START,
-                          struct ClientStartMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(request_address,
-                          GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS,
-                          struct RequestAddressMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(request_address_cancel,
-                          GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL,
-                          struct RequestAddressMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(request_address_list,
-                          GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST,
-                          struct AddressListRequestMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(address_add,
-                        GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD,
-                        struct AddressAddMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(address_update,
-                          GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE,
-                          struct AddressUpdateMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(address_destroyed,
-                          GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED,
-                          struct AddressDestroyedMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(reservation_request,
-                          GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST,
-                          struct ReservationRequestMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(preference_change,
-                        GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE,
-                        struct ChangePreferenceMessage,
-                        NULL),
-  GNUNET_MQ_hd_var_size(feedback,
-                        GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK,
-                        struct FeedbackPreferenceMessage,
-                        NULL),
-  GNUNET_MQ_handler_end());
+  GNUNET_MQ_hd_fixed_size (ats_start,
+                           GNUNET_MESSAGE_TYPE_ATS_START,
+                           struct ClientStartMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (request_address,
+                           GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS,
+                           struct RequestAddressMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (request_address_cancel,
+                           GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL,
+                           struct RequestAddressMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (request_address_list,
+                           GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST,
+                           struct AddressListRequestMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (address_add,
+                         GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD,
+                         struct AddressAddMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (address_update,
+                           GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE,
+                           struct AddressUpdateMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (address_destroyed,
+                           GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED,
+                           struct AddressDestroyedMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (reservation_request,
+                           GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST,
+                           struct ReservationRequestMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (preference_change,
+                         GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE,
+                         struct ChangePreferenceMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (feedback,
+                         GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK,
+                         struct FeedbackPreferenceMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
 
 
 /* end of gnunet-service-ats.c */
diff --git a/src/ats/gnunet-service-ats.h b/src/ats/gnunet-service-ats.h
index 6abe57fdb..85d522b9f 100644
--- a/src/ats/gnunet-service-ats.h
+++ b/src/ats/gnunet-service-ats.h
@@ -31,7 +31,7 @@
 
 #define GAS_normalization_queue_length 3
 
-#define BANDWIDTH_ZERO GNUNET_BANDWIDTH_value_init(0)
+#define BANDWIDTH_ZERO GNUNET_BANDWIDTH_value_init (0)
 
 /**
  * Handle for statistics.
diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c
index 8ca245b1e..7c73cbf5b 100644
--- a/src/ats/gnunet-service-ats_addresses.c
+++ b/src/ats/gnunet-service-ats_addresses.c
@@ -41,12 +41,12 @@ struct GNUNET_CONTAINER_MultiPeerMap *GSA_addresses;
  * Update statistic on number of addresses.
  */
 static void
-update_addresses_stat()
+update_addresses_stat ()
 {
-  GNUNET_STATISTICS_set(GSA_stats,
-                        "# addresses",
-                        GNUNET_CONTAINER_multipeermap_size(GSA_addresses),
-                        GNUNET_NO);
+  GNUNET_STATISTICS_set (GSA_stats,
+                         "# addresses",
+                         GNUNET_CONTAINER_multipeermap_size (GSA_addresses),
+                         GNUNET_NO);
 }
 
 
@@ -56,25 +56,25 @@ update_addresses_stat()
  * @param addr address to destroy
  */
 static void
-free_address(struct ATS_Address *addr)
+free_address (struct ATS_Address *addr)
 {
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(GSA_addresses,
-                                                     &addr->peer,
-                                                     addr));
-  update_addresses_stat();
-  GAS_plugin_delete_address(addr);
-  GAS_performance_notify_all_clients(&addr->peer,
-                                     addr->plugin,
-                                     addr->addr,
-                                     addr->addr_len,
-                                     GNUNET_NO,
-                                     NULL,
-                                     addr->local_address_info,
-                                     GNUNET_BANDWIDTH_ZERO,
-                                     GNUNET_BANDWIDTH_ZERO);
-  GNUNET_free(addr->plugin);
-  GNUNET_free(addr);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (GSA_addresses,
+                                                       &addr->peer,
+                                                       addr));
+  update_addresses_stat ();
+  GAS_plugin_delete_address (addr);
+  GAS_performance_notify_all_clients (&addr->peer,
+                                      addr->plugin,
+                                      addr->addr,
+                                      addr->addr_len,
+                                      GNUNET_NO,
+                                      NULL,
+                                      addr->local_address_info,
+                                      GNUNET_BANDWIDTH_ZERO,
+                                      GNUNET_BANDWIDTH_ZERO);
+  GNUNET_free (addr->plugin);
+  GNUNET_free (addr);
 }
 
 
@@ -84,7 +84,7 @@ free_address(struct ATS_Address *addr)
  * @param norm normalization data to initialize
  */
 static void
-init_norm(struct GAS_NormalizationInfo *norm)
+init_norm (struct GAS_NormalizationInfo *norm)
 {
   unsigned int c;
 
@@ -105,29 +105,29 @@ init_norm(struct GAS_NormalizationInfo *norm)
  * @return the ATS_Address
  */
 static struct ATS_Address *
-create_address(const struct GNUNET_PeerIdentity *peer,
-               const char *plugin_name,
-               const void *plugin_addr,
-               size_t plugin_addr_len,
-               uint32_t local_address_info,
-               uint32_t session_id)
+create_address (const struct GNUNET_PeerIdentity *peer,
+                const char *plugin_name,
+                const void *plugin_addr,
+                size_t plugin_addr_len,
+                uint32_t local_address_info,
+                uint32_t session_id)
 {
   struct ATS_Address *aa;
 
-  aa = GNUNET_malloc(sizeof(struct ATS_Address) + plugin_addr_len);
+  aa = GNUNET_malloc (sizeof(struct ATS_Address) + plugin_addr_len);
   aa->peer = *peer;
   aa->addr_len = plugin_addr_len;
   aa->addr = &aa[1];
-  GNUNET_memcpy(&aa[1],
-                plugin_addr,
-                plugin_addr_len);
-  aa->plugin = GNUNET_strdup(plugin_name);
+  GNUNET_memcpy (&aa[1],
+                 plugin_addr,
+                 plugin_addr_len);
+  aa->plugin = GNUNET_strdup (plugin_name);
   aa->session_id = session_id;
   aa->local_address_info = local_address_info;
-  init_norm(&aa->norm_delay);
-  init_norm(&aa->norm_distance);
-  init_norm(&aa->norm_utilization_in);
-  init_norm(&aa->norm_utilization_out);
+  init_norm (&aa->norm_delay);
+  init_norm (&aa->norm_distance);
+  init_norm (&aa->norm_utilization_in);
+  init_norm (&aa->norm_utilization_out);
   return aa;
 }
 
@@ -135,7 +135,8 @@ create_address(const struct GNUNET_PeerIdentity *peer,
 /**
  * Closure for #find_address_cb()
  */
-struct FindAddressContext {
+struct FindAddressContext
+{
   /**
    * Session Id to look for.
    */
@@ -157,18 +158,18 @@ struct FindAddressContext {
  * @return #GNUNET_YES to continue, #GNUNET_NO if address is found
  */
 static int
-find_address_cb(void *cls,
-                const struct GNUNET_PeerIdentity *key,
-                void *value)
+find_address_cb (void *cls,
+                 const struct GNUNET_PeerIdentity *key,
+                 void *value)
 {
   struct FindAddressContext *fac = cls;
   struct ATS_Address *aa = value;
 
   if (aa->session_id == fac->session_id)
-    {
-      fac->exact_address = aa;
-      return GNUNET_NO;
-    }
+  {
+    fac->exact_address = aa;
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -181,16 +182,16 @@ find_address_cb(void *cls,
  * @return an ATS_address or NULL
  */
 static struct ATS_Address *
-find_exact_address(const struct GNUNET_PeerIdentity *peer,
-                   uint32_t session_id)
+find_exact_address (const struct GNUNET_PeerIdentity *peer,
+                    uint32_t session_id)
 {
   struct FindAddressContext fac;
 
   fac.exact_address = NULL;
   fac.session_id = session_id;
-  GNUNET_CONTAINER_multipeermap_get_multiple(GSA_addresses,
-                                             peer,
-                                             &find_address_cb, &fac);
+  GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
+                                              peer,
+                                              &find_address_cb, &fac);
   return fac.exact_address;
 }
 
@@ -207,58 +208,60 @@ find_exact_address(const struct GNUNET_PeerIdentity *peer,
  * @param prop performance information for this address
  */
 void
-GAS_addresses_add(const struct GNUNET_PeerIdentity *peer,
-                  const char *plugin_name,
-                  const void *plugin_addr,
-                  size_t plugin_addr_len,
-                  uint32_t local_address_info,
-                  uint32_t session_id,
-                  const struct GNUNET_ATS_Properties *prop)
+GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
+                   const char *plugin_name,
+                   const void *plugin_addr,
+                   size_t plugin_addr_len,
+                   uint32_t local_address_info,
+                   uint32_t session_id,
+                   const struct GNUNET_ATS_Properties *prop)
 {
   struct ATS_Address *new_address;
 
-  if (NULL != find_exact_address(peer,
-                                 session_id))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
-  new_address = create_address(peer,
-                               plugin_name,
-                               plugin_addr,
-                               plugin_addr_len,
-                               local_address_info,
-                               session_id);
+  if (NULL != find_exact_address (peer,
+                                  session_id))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
+  new_address = create_address (peer,
+                                plugin_name,
+                                plugin_addr,
+                                plugin_addr_len,
+                                local_address_info,
+                                session_id);
   /* Add a new address */
   new_address->properties = *prop;
-  new_address->t_added = GNUNET_TIME_absolute_get();
-  new_address->t_last_activity = GNUNET_TIME_absolute_get();
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_put(GSA_addresses,
-                                                  peer,
-                                                  new_address,
-                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  update_addresses_stat();
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Adding new address for peer `%s' slot %u\n",
-             GNUNET_i2s(peer),
-             session_id);
+  new_address->t_added = GNUNET_TIME_absolute_get ();
+  new_address->t_last_activity = GNUNET_TIME_absolute_get ();
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_put (GSA_addresses,
+                                                    peer,
+                                                    new_address,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  update_addresses_stat ();
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Adding new address for peer `%s' slot %u\n",
+              GNUNET_i2s (peer),
+              session_id);
   /* Tell solver about new address */
-  GAS_plugin_solver_lock();
-  GAS_plugin_new_address(new_address);
-  GAS_normalization_update_property(new_address);  // FIXME: needed?
-  GAS_plugin_solver_unlock();
+  GAS_plugin_solver_lock ();
+  GAS_plugin_new_address (new_address);
+  GAS_normalization_update_property (new_address);  // FIXME: needed?
+  GAS_plugin_solver_unlock ();
   /* Notify performance clients about new address */
-  GAS_performance_notify_all_clients(&new_address->peer,
-                                     new_address->plugin,
-                                     new_address->addr,
-                                     new_address->addr_len,
-                                     new_address->active,
-                                     &new_address->properties,
-                                     new_address->local_address_info,
-                                     GNUNET_BANDWIDTH_value_init(new_address->assigned_bw_out),
-                                     GNUNET_BANDWIDTH_value_init(new_address->assigned_bw_in));
+  GAS_performance_notify_all_clients (&new_address->peer,
+                                      new_address->plugin,
+                                      new_address->addr,
+                                      new_address->addr_len,
+                                      new_address->active,
+                                      &new_address->properties,
+                                      new_address->local_address_info,
+                                      GNUNET_BANDWIDTH_value_init (
+                                        new_address->assigned_bw_out),
+                                      GNUNET_BANDWIDTH_value_init (
+                                        new_address->assigned_bw_in));
 }
 
 
@@ -270,45 +273,47 @@ GAS_addresses_add(const struct GNUNET_PeerIdentity *peer,
  * @param prop performance information for this address
  */
 void
-GAS_addresses_update(const struct GNUNET_PeerIdentity *peer,
-                     uint32_t session_id,
-                     const struct GNUNET_ATS_Properties *prop)
+GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
+                      uint32_t session_id,
+                      const struct GNUNET_ATS_Properties *prop)
 {
   struct ATS_Address *aa;
 
   /* Get existing address */
-  aa = find_exact_address(peer,
-                          session_id);
+  aa = find_exact_address (peer,
+                           session_id);
   if (NULL == aa)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   if (NULL == aa->solver_information)
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received ADDRESS_UPDATE for peer `%s' slot %u\n",
-             GNUNET_i2s(peer),
-             (unsigned int)session_id);
-  GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ADDRESS_UPDATE for peer `%s' slot %u\n",
+              GNUNET_i2s (peer),
+              (unsigned int) session_id);
+  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
   /* Update address */
-  aa->t_last_activity = GNUNET_TIME_absolute_get();
+  aa->t_last_activity = GNUNET_TIME_absolute_get ();
   aa->properties = *prop;
   /* Notify performance clients about updated address */
-  GAS_performance_notify_all_clients(&aa->peer,
-                                     aa->plugin,
-                                     aa->addr,
-                                     aa->addr_len,
-                                     aa->active,
-                                     prop,
-                                     aa->local_address_info,
-                                     GNUNET_BANDWIDTH_value_init(aa->assigned_bw_out),
-                                     GNUNET_BANDWIDTH_value_init(aa->assigned_bw_in));
-
-  GAS_normalization_update_property(aa);
+  GAS_performance_notify_all_clients (&aa->peer,
+                                      aa->plugin,
+                                      aa->addr,
+                                      aa->addr_len,
+                                      aa->active,
+                                      prop,
+                                      aa->local_address_info,
+                                      GNUNET_BANDWIDTH_value_init (
+                                        aa->assigned_bw_out),
+                                      GNUNET_BANDWIDTH_value_init (
+                                        aa->assigned_bw_in));
+
+  GAS_normalization_update_property (aa);
 }
 
 
@@ -319,24 +324,24 @@ GAS_addresses_update(const struct GNUNET_PeerIdentity *peer,
  * @param session_id session id, can never be 0
  */
 void
-GAS_addresses_destroy(const struct GNUNET_PeerIdentity *peer,
-                      uint32_t session_id)
+GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
+                       uint32_t session_id)
 {
   struct ATS_Address *ea;
 
   /* Get existing address */
-  ea = find_exact_address(peer,
-                          session_id);
+  ea = find_exact_address (peer,
+                           session_id);
   if (NULL == ea)
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received ADDRESS_DESTROYED for peer `%s' session %u\n",
-             GNUNET_i2s(peer),
-             session_id);
-  free_address(ea);
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ADDRESS_DESTROYED for peer `%s' session %u\n",
+              GNUNET_i2s (peer),
+              session_id);
+  free_address (ea);
 }
 
 
@@ -347,12 +352,12 @@ GAS_addresses_destroy(const struct GNUNET_PeerIdentity *peer,
  * and receives updates when the solver changes the resource allocation.
  */
 void
-GAS_addresses_init()
+GAS_addresses_init ()
 {
   GSA_addresses
-    = GNUNET_CONTAINER_multipeermap_create(128,
-                                           GNUNET_NO);
-  update_addresses_stat();
+    = GNUNET_CONTAINER_multipeermap_create (128,
+                                            GNUNET_NO);
+  update_addresses_stat ();
 }
 
 
@@ -365,13 +370,13 @@ GAS_addresses_init()
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-destroy_all_address_it(void *cls,
-                       const struct GNUNET_PeerIdentity *key,
-                       void *value)
+destroy_all_address_it (void *cls,
+                        const struct GNUNET_PeerIdentity *key,
+                        void *value)
 {
   struct ATS_Address *aa = value;
 
-  free_address(aa);
+  free_address (aa);
   return GNUNET_OK;
 }
 
@@ -380,18 +385,18 @@ destroy_all_address_it(void *cls,
  * Remove all addresses
  */
 void
-GAS_addresses_destroy_all()
+GAS_addresses_destroy_all ()
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Destroying all addresses\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Destroying all addresses\n");
   if (0 ==
-      GNUNET_CONTAINER_multipeermap_size(GSA_addresses))
+      GNUNET_CONTAINER_multipeermap_size (GSA_addresses))
     return;
-  GAS_plugin_solver_lock();
-  GNUNET_CONTAINER_multipeermap_iterate(GSA_addresses,
-                                        &destroy_all_address_it,
-                                        NULL);
-  GAS_plugin_solver_unlock();
+  GAS_plugin_solver_lock ();
+  GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                         &destroy_all_address_it,
+                                         NULL);
+  GAS_plugin_solver_unlock ();
 }
 
 
@@ -399,14 +404,14 @@ GAS_addresses_destroy_all()
  * Shutdown address subsystem.
  */
 void
-GAS_addresses_done()
+GAS_addresses_done ()
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Shutting down addresses\n");
-  GAS_plugin_solver_lock();
-  GAS_addresses_destroy_all();
-  GAS_plugin_solver_unlock();
-  GNUNET_CONTAINER_multipeermap_destroy(GSA_addresses);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Shutting down addresses\n");
+  GAS_plugin_solver_lock ();
+  GAS_addresses_destroy_all ();
+  GAS_plugin_solver_unlock ();
+  GNUNET_CONTAINER_multipeermap_destroy (GSA_addresses);
   GSA_addresses = NULL;
 }
 
@@ -414,7 +419,8 @@ GAS_addresses_done()
 /**
  * Closure for #peerinfo_it().
  */
-struct PeerInfoIteratorContext {
+struct PeerInfoIteratorContext
+{
   /**
    * Function to call for each address.
    */
@@ -436,23 +442,23 @@ struct PeerInfoIteratorContext {
  * @return #GNUNET_OK to continue
  */
 static int
-peerinfo_it(void *cls,
-            const struct GNUNET_PeerIdentity *key,
-            void *value)
+peerinfo_it (void *cls,
+             const struct GNUNET_PeerIdentity *key,
+             void *value)
 {
   struct PeerInfoIteratorContext *pi_ctx = cls;
   struct ATS_Address *addr = value;
 
-  pi_ctx->it(pi_ctx->it_cls,
-             &addr->peer,
-             addr->plugin,
-             addr->addr,
-             addr->addr_len,
-             addr->active,
-             &addr->properties,
-             addr->local_address_info,
-             GNUNET_BANDWIDTH_value_init(addr->assigned_bw_out),
-             GNUNET_BANDWIDTH_value_init(addr->assigned_bw_in));
+  pi_ctx->it (pi_ctx->it_cls,
+              &addr->peer,
+              addr->plugin,
+              addr->addr,
+              addr->addr_len,
+              addr->active,
+              &addr->properties,
+              addr->local_address_info,
+              GNUNET_BANDWIDTH_value_init (addr->assigned_bw_out),
+              GNUNET_BANDWIDTH_value_init (addr->assigned_bw_in));
   return GNUNET_OK;
 }
 
@@ -465,41 +471,42 @@ peerinfo_it(void *cls,
  * @param pi_it_cls the closure for @a pi_it
  */
 void
-GAS_addresses_get_peer_info(const struct GNUNET_PeerIdentity *peer,
-                            GNUNET_ATS_PeerInfo_Iterator pi_it,
-                            void *pi_it_cls)
+GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer,
+                             GNUNET_ATS_PeerInfo_Iterator pi_it,
+                             void *pi_it_cls)
 {
   struct PeerInfoIteratorContext pi_ctx;
 
   if (NULL == pi_it)
-    {
-      /* does not make sense without callback */
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Returning information for %s from a total of %u known addresses\n",
-             (NULL == peer)
-             ? "all peers"
-             : GNUNET_i2s(peer),
-             (unsigned int)GNUNET_CONTAINER_multipeermap_size(GSA_addresses));
+  {
+    /* does not make sense without callback */
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Returning information for %s from a total of %u known addresses\n",
+              (NULL == peer)
+              ? "all peers"
+              : GNUNET_i2s (peer),
+              (unsigned int) GNUNET_CONTAINER_multipeermap_size (
+                GSA_addresses));
   pi_ctx.it = pi_it;
   pi_ctx.it_cls = pi_it_cls;
   if (NULL == peer)
-    GNUNET_CONTAINER_multipeermap_iterate(GSA_addresses,
-                                          &peerinfo_it,
-                                          &pi_ctx);
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                           &peerinfo_it,
+                                           &pi_ctx);
   else
-    GNUNET_CONTAINER_multipeermap_get_multiple(GSA_addresses,
-                                               peer,
-                                               &peerinfo_it, &pi_ctx);
-  pi_it(pi_it_cls,
-        NULL, NULL, NULL, 0,
-        GNUNET_NO,
-        NULL,
-        GNUNET_HELLO_ADDRESS_INFO_NONE,
-        GNUNET_BANDWIDTH_ZERO,
-        GNUNET_BANDWIDTH_ZERO);
+    GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
+                                                peer,
+                                                &peerinfo_it, &pi_ctx);
+  pi_it (pi_it_cls,
+         NULL, NULL, NULL, 0,
+         GNUNET_NO,
+         NULL,
+         GNUNET_HELLO_ADDRESS_INFO_NONE,
+         GNUNET_BANDWIDTH_ZERO,
+         GNUNET_BANDWIDTH_ZERO);
 }
 
 
@@ -507,7 +514,8 @@ GAS_addresses_get_peer_info(const struct GNUNET_PeerIdentity *peer,
  * Information we need for the callbacks to return a list of addresses
  * back to the client.
  */
-struct AddressIteration {
+struct AddressIteration
+{
   /**
    * Actual handle to the client.
    */
@@ -541,16 +549,16 @@ struct AddressIteration {
  * @param bandwidth_in current inbound bandwidth assigned to address
  */
 static void
-transmit_req_addr(struct AddressIteration *ai,
-                  const struct GNUNET_PeerIdentity *id,
-                  const char *plugin_name,
-                  const void *plugin_addr,
-                  size_t plugin_addr_len,
-                  int active,
-                  const struct GNUNET_ATS_Properties *prop,
-                  enum GNUNET_HELLO_AddressInfo local_address_info,
-                  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+transmit_req_addr (struct AddressIteration *ai,
+                   const struct GNUNET_PeerIdentity *id,
+                   const char *plugin_name,
+                   const void *plugin_addr,
+                   size_t plugin_addr_len,
+                   int active,
+                   const struct GNUNET_ATS_Properties *prop,
+                   enum GNUNET_HELLO_AddressInfo local_address_info,
+                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 
 {
   struct GNUNET_MQ_Envelope *env;
@@ -560,37 +568,37 @@ transmit_req_addr(struct AddressIteration *ai,
   size_t msize;
 
   if (NULL != plugin_name)
-    plugin_name_length = strlen(plugin_name) + 1;
+    plugin_name_length = strlen (plugin_name) + 1;
   else
     plugin_name_length = 0;
   msize = plugin_addr_len + plugin_name_length;
 
-  GNUNET_assert(sizeof(struct PeerInformationMessage) + msize
-                < GNUNET_MAX_MESSAGE_SIZE);
-  env = GNUNET_MQ_msg_extra(msg,
-                            msize,
-                            GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE);
-  msg->id = htonl(ai->id);
+  GNUNET_assert (sizeof(struct PeerInformationMessage) + msize
+                 < GNUNET_MAX_MESSAGE_SIZE);
+  env = GNUNET_MQ_msg_extra (msg,
+                             msize,
+                             GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE);
+  msg->id = htonl (ai->id);
   if (NULL != id)
     msg->peer = *id;
-  msg->address_length = htons(plugin_addr_len);
-  msg->address_active = ntohl(active);
-  msg->plugin_name_length = htons(plugin_name_length);
+  msg->address_length = htons (plugin_addr_len);
+  msg->address_active = ntohl (active);
+  msg->plugin_name_length = htons (plugin_name_length);
   msg->bandwidth_out = bandwidth_out;
   msg->bandwidth_in = bandwidth_in;
   if (NULL != prop)
-    GNUNET_ATS_properties_hton(&msg->properties,
-                               prop);
-  msg->address_local_info = htonl((uint32_t)local_address_info);
-  addrp = (char *)&msg[1];
-  GNUNET_memcpy(addrp,
-                plugin_addr,
-                plugin_addr_len);
+    GNUNET_ATS_properties_hton (&msg->properties,
+                                prop);
+  msg->address_local_info = htonl ((uint32_t) local_address_info);
+  addrp = (char *) &msg[1];
+  GNUNET_memcpy (addrp,
+                 plugin_addr,
+                 plugin_addr_len);
   if (NULL != plugin_name)
-    strcpy(&addrp[plugin_addr_len],
-           plugin_name);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(ai->client),
-                 env);
+    strcpy (&addrp[plugin_addr_len],
+            plugin_name);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (ai->client),
+                  env);
 }
 
 
@@ -610,48 +618,48 @@ transmit_req_addr(struct AddressIteration *ai,
  * @param bandwidth_in current inbound bandwidth assigned to address
  */
 static void
-req_addr_peerinfo_it(void *cls,
-                     const struct GNUNET_PeerIdentity *id,
-                     const char *plugin_name,
-                     const void *plugin_addr,
-                     size_t plugin_addr_len,
-                     int active,
-                     const struct GNUNET_ATS_Properties *prop,
-                     enum GNUNET_HELLO_AddressInfo local_address_info,
-                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+req_addr_peerinfo_it (void *cls,
+                      const struct GNUNET_PeerIdentity *id,
+                      const char *plugin_name,
+                      const void *plugin_addr,
+                      size_t plugin_addr_len,
+                      int active,
+                      const struct GNUNET_ATS_Properties *prop,
+                      enum GNUNET_HELLO_AddressInfo local_address_info,
+                      struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                      struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
   struct AddressIteration *ai = cls;
 
   if ((NULL == id) &&
       (NULL == plugin_name) &&
       (NULL == plugin_addr))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Address iteration done for one peer\n");
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Callback for %s peer `%s' plugin `%s' BW out %u, BW in %u\n",
-             (active == GNUNET_YES) ? "ACTIVE" : "INACTIVE",
-             GNUNET_i2s(id),
-             plugin_name,
-             (unsigned int)ntohl(bandwidth_out.value__),
-             (unsigned int)ntohl(bandwidth_in.value__));
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Address iteration done for one peer\n");
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Callback for %s peer `%s' plugin `%s' BW out %u, BW in %u\n",
+              (active == GNUNET_YES) ? "ACTIVE" : "INACTIVE",
+              GNUNET_i2s (id),
+              plugin_name,
+              (unsigned int) ntohl (bandwidth_out.value__),
+              (unsigned int) ntohl (bandwidth_in.value__));
   /* Transmit result (either if address is active, or if
      client wanted all addresses) */
   if ((GNUNET_YES != ai->all) &&
       (GNUNET_YES != active))
     return;
-  transmit_req_addr(ai,
-                    id,
-                    plugin_name,
-                    plugin_addr, plugin_addr_len,
-                    active,
-                    prop,
-                    local_address_info,
-                    bandwidth_out,
-                    bandwidth_in);
+  transmit_req_addr (ai,
+                     id,
+                     plugin_name,
+                     plugin_addr, plugin_addr_len,
+                     active,
+                     prop,
+                     local_address_info,
+                     bandwidth_out,
+                     bandwidth_in);
 }
 
 
@@ -662,45 +670,45 @@ req_addr_peerinfo_it(void *cls,
  * @param alrm the request message
  */
 void
-GAS_handle_request_address_list(struct GNUNET_SERVICE_Client *client,
-                                const struct AddressListRequestMessage *alrm)
+GAS_handle_request_address_list (struct GNUNET_SERVICE_Client *client,
+                                 const struct AddressListRequestMessage *alrm)
 {
   struct AddressIteration ai;
   struct GNUNET_PeerIdentity allzeros;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received ADDRESSLIST_REQUEST message\n");
-  ai.all = ntohl(alrm->all);
-  ai.id = ntohl(alrm->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ADDRESSLIST_REQUEST message\n");
+  ai.all = ntohl (alrm->all);
+  ai.id = ntohl (alrm->id);
   ai.client = client;
 
-  memset(&allzeros,
-         '\0',
-         sizeof(struct GNUNET_PeerIdentity));
-  if (0 == GNUNET_is_zero(&alrm->peer))
-    {
-      /* Return addresses for all peers */
-      GAS_addresses_get_peer_info(NULL,
-                                  &req_addr_peerinfo_it,
-                                  &ai);
-    }
+  memset (&allzeros,
+          '\0',
+          sizeof(struct GNUNET_PeerIdentity));
+  if (0 == GNUNET_is_zero (&alrm->peer))
+  {
+    /* Return addresses for all peers */
+    GAS_addresses_get_peer_info (NULL,
+                                 &req_addr_peerinfo_it,
+                                 &ai);
+  }
   else
-    {
-      /* Return addresses for a specific peer */
-      GAS_addresses_get_peer_info(&alrm->peer,
-                                  &req_addr_peerinfo_it,
-                                  &ai);
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Finished handling `%s' message\n",
-             "ADDRESSLIST_REQUEST");
-  transmit_req_addr(&ai,
-                    NULL, NULL, NULL,
-                    0, GNUNET_NO,
-                    NULL,
-                    GNUNET_HELLO_ADDRESS_INFO_NONE,
-                    GNUNET_BANDWIDTH_ZERO,
-                    GNUNET_BANDWIDTH_ZERO);
+  {
+    /* Return addresses for a specific peer */
+    GAS_addresses_get_peer_info (&alrm->peer,
+                                 &req_addr_peerinfo_it,
+                                 &ai);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finished handling `%s' message\n",
+              "ADDRESSLIST_REQUEST");
+  transmit_req_addr (&ai,
+                     NULL, NULL, NULL,
+                     0, GNUNET_NO,
+                     NULL,
+                     GNUNET_HELLO_ADDRESS_INFO_NONE,
+                     GNUNET_BANDWIDTH_ZERO,
+                     GNUNET_BANDWIDTH_ZERO);
 }
 
 
diff --git a/src/ats/gnunet-service-ats_addresses.h b/src/ats/gnunet-service-ats_addresses.h
index f7dd98b1e..a18cce2c7 100644
--- a/src/ats/gnunet-service-ats_addresses.h
+++ b/src/ats/gnunet-service-ats_addresses.h
@@ -221,12 +221,14 @@
 /*
  * How long will address suggestions blocked after a suggestion
  */
-#define ATS_BLOCKING_DELTA GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100)
+#define ATS_BLOCKING_DELTA GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MILLISECONDS, 100)
 
 /**
  * Information provided by ATS normalization
  */
-struct GAS_NormalizationInfo {
+struct GAS_NormalizationInfo
+{
   /**
    * Next index to use in averaging queue
    */
@@ -252,7 +254,8 @@ struct GAS_NormalizationInfo {
 /**
  * Address with additional information
  */
-struct ATS_Address {
+struct ATS_Address
+{
   /**
    * Peer ID this address is for.
    */
@@ -366,14 +369,14 @@ extern struct GNUNET_CONTAINER_MultiPeerMap *GSA_addresses;
  * known and current performance information.
  */
 void
-GAS_addresses_init(void);
+GAS_addresses_init (void);
 
 
 /**
  * Shutdown address subsystem.
  */
 void
-GAS_addresses_done(void);
+GAS_addresses_done (void);
 
 
 /**
@@ -388,13 +391,13 @@ GAS_addresses_done(void);
  * @param prop performance information for this address
  */
 void
-GAS_addresses_add(const struct GNUNET_PeerIdentity *peer,
-                  const char *plugin_name,
-                  const void *plugin_addr,
-                  size_t plugin_addr_len,
-                  uint32_t local_address_info,
-                  uint32_t session_id,
-                  const struct GNUNET_ATS_Properties *prop);
+GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
+                   const char *plugin_name,
+                   const void *plugin_addr,
+                   size_t plugin_addr_len,
+                   uint32_t local_address_info,
+                   uint32_t session_id,
+                   const struct GNUNET_ATS_Properties *prop);
 
 
 /**
@@ -405,9 +408,9 @@ GAS_addresses_add(const struct GNUNET_PeerIdentity *peer,
  * @param prop performance information for this address
  */
 void
-GAS_addresses_update(const struct GNUNET_PeerIdentity *peer,
-                     uint32_t session_id,
-                     const struct GNUNET_ATS_Properties *prop);
+GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
+                      uint32_t session_id,
+                      const struct GNUNET_ATS_Properties *prop);
 
 
 /**
@@ -417,15 +420,15 @@ GAS_addresses_update(const struct GNUNET_PeerIdentity *peer,
  * @param session_id session id, can never be 0
  */
 void
-GAS_addresses_destroy(const struct GNUNET_PeerIdentity *peer,
-                      uint32_t session_id);
+GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
+                       uint32_t session_id);
 
 
 /**
  * Remove all addresses.
  */
 void
-GAS_addresses_destroy_all(void);
+GAS_addresses_destroy_all (void);
 
 
 /**
@@ -450,9 +453,12 @@ typedef void
                                  size_t plugin_addr_len,
                                  const int address_active,
                                  const struct GNUNET_ATS_Properties *prop,
-                                 enum GNUNET_HELLO_AddressInfo local_address_info,
-                                 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                                 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in);
+                                 enum GNUNET_HELLO_AddressInfo
+                                 local_address_info,
+                                 struct GNUNET_BANDWIDTH_Value32NBO
+                                 bandwidth_out,
+                                 struct GNUNET_BANDWIDTH_Value32NBO
+                                 bandwidth_in);
 
 
 /**
@@ -463,9 +469,9 @@ typedef void
  * @param pi_it_cls the closure for @a pi_it
  */
 void
-GAS_addresses_get_peer_info(const struct GNUNET_PeerIdentity *peer,
-                            GNUNET_ATS_PeerInfo_Iterator pi_it,
-                            void *pi_it_cls);
+GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer,
+                             GNUNET_ATS_PeerInfo_Iterator pi_it,
+                             void *pi_it_cls);
 
 
 /**
@@ -475,8 +481,8 @@ GAS_addresses_get_peer_info(const struct GNUNET_PeerIdentity *peer,
  * @param alrm the request message
  */
 void
-GAS_handle_request_address_list(struct GNUNET_SERVICE_Client *client,
-                                const struct AddressListRequestMessage *alrm);
+GAS_handle_request_address_list (struct GNUNET_SERVICE_Client *client,
+                                 const struct AddressListRequestMessage *alrm);
 
 
 #endif
diff --git a/src/ats/gnunet-service-ats_connectivity.c b/src/ats/gnunet-service-ats_connectivity.c
index f71d18e82..05046f007 100644
--- a/src/ats/gnunet-service-ats_connectivity.c
+++ b/src/ats/gnunet-service-ats_connectivity.c
@@ -35,7 +35,8 @@
 /**
  * Active connection requests.
  */
-struct ConnectionRequest {
+struct ConnectionRequest
+{
   /**
    * Client that made the request.
    */
@@ -60,14 +61,14 @@ static struct GNUNET_CONTAINER_MultiPeerMap *connection_requests;
  * @return #GNUNET_YES if so, #GNUNET_NO if not
  */
 unsigned int
-GAS_connectivity_has_peer(void *cls,
-                          const struct GNUNET_PeerIdentity *peer)
+GAS_connectivity_has_peer (void *cls,
+                           const struct GNUNET_PeerIdentity *peer)
 {
   if (NULL == connection_requests)
     return 0;
   /* TODO: return sum of 'strength's of connectivity requests */
-  return GNUNET_CONTAINER_multipeermap_contains(connection_requests,
-                                                peer);
+  return GNUNET_CONTAINER_multipeermap_contains (connection_requests,
+                                                 peer);
 }
 
 
@@ -78,22 +79,22 @@ GAS_connectivity_has_peer(void *cls,
  * @param message the request message
  */
 void
-GAS_handle_request_address(struct GNUNET_SERVICE_Client *client,
-                           const struct RequestAddressMessage *msg)
+GAS_handle_request_address (struct GNUNET_SERVICE_Client *client,
+                            const struct RequestAddressMessage *msg)
 {
   struct ConnectionRequest *cr;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received `%s' message\n",
-             "GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received `%s' message\n",
+              "GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS");
   /* FIXME: should not ignore "msg->strength" */
-  cr = GNUNET_new(struct ConnectionRequest);
+  cr = GNUNET_new (struct ConnectionRequest);
   cr->client = client;
-  (void)GNUNET_CONTAINER_multipeermap_put(connection_requests,
-                                          &msg->peer,
-                                          cr,
-                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  GAS_plugin_request_connect_start(&msg->peer);
+  (void) GNUNET_CONTAINER_multipeermap_put (connection_requests,
+                                            &msg->peer,
+                                            cr,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GAS_plugin_request_connect_start (&msg->peer);
 }
 
 
@@ -107,25 +108,25 @@ GAS_handle_request_address(struct GNUNET_SERVICE_Client *client,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_matching_requests(void *cls,
-                       const struct GNUNET_PeerIdentity *pid,
-                       void *value)
+free_matching_requests (void *cls,
+                        const struct GNUNET_PeerIdentity *pid,
+                        void *value)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct ConnectionRequest *cr = value;
 
   if (cr->client == client)
-    {
-      GAS_plugin_request_connect_stop(pid);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Removed request pending for peer `%s\n",
-                 GNUNET_i2s(pid));
-      GNUNET_assert(GNUNET_YES ==
-                    GNUNET_CONTAINER_multipeermap_remove(connection_requests,
+  {
+    GAS_plugin_request_connect_stop (pid);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Removed request pending for peer `%s\n",
+                GNUNET_i2s (pid));
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_remove (connection_requests,
                                                          pid,
                                                          cr));
-      GNUNET_free(cr);
-    }
+    GNUNET_free (cr);
+  }
   return GNUNET_OK;
 }
 
@@ -138,17 +139,17 @@ free_matching_requests(void *cls,
  * @param msg the request message
  */
 void
-GAS_handle_request_address_cancel(struct GNUNET_SERVICE_Client *client,
-                                  const struct RequestAddressMessage *msg)
+GAS_handle_request_address_cancel (struct GNUNET_SERVICE_Client *client,
+                                   const struct RequestAddressMessage *msg)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL message for peer %s\n",
-             GNUNET_i2s(&msg->peer));
-  GNUNET_break(0 == ntohl(msg->strength));
-  GNUNET_CONTAINER_multipeermap_get_multiple(connection_requests,
-                                             &msg->peer,
-                                             &free_matching_requests,
-                                             client);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL message for peer %s\n",
+              GNUNET_i2s (&msg->peer));
+  GNUNET_break (0 == ntohl (msg->strength));
+  GNUNET_CONTAINER_multipeermap_get_multiple (connection_requests,
+                                              &msg->peer,
+                                              &free_matching_requests,
+                                              client);
 }
 
 
@@ -159,11 +160,11 @@ GAS_handle_request_address_cancel(struct GNUNET_SERVICE_Client *client,
  * @param client handle of the (now dead) client
  */
 void
-GAS_connectivity_remove_client(struct GNUNET_SERVICE_Client *client)
+GAS_connectivity_remove_client (struct GNUNET_SERVICE_Client *client)
 {
-  GNUNET_CONTAINER_multipeermap_iterate(connection_requests,
-                                        &free_matching_requests,
-                                        client);
+  GNUNET_CONTAINER_multipeermap_iterate (connection_requests,
+                                         &free_matching_requests,
+                                         client);
 }
 
 
@@ -171,11 +172,11 @@ GAS_connectivity_remove_client(struct GNUNET_SERVICE_Client *client)
  * Shutdown connectivity subsystem.
  */
 void
-GAS_connectivity_init()
+GAS_connectivity_init ()
 {
   connection_requests
-    = GNUNET_CONTAINER_multipeermap_create(32,
-                                           GNUNET_NO);
+    = GNUNET_CONTAINER_multipeermap_create (32,
+                                            GNUNET_NO);
 }
 
 
@@ -188,15 +189,15 @@ GAS_connectivity_init()
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_request(void *cls,
-             const struct GNUNET_PeerIdentity *pid,
-             void *value)
+free_request (void *cls,
+              const struct GNUNET_PeerIdentity *pid,
+              void *value)
 {
   struct ConnectionRequest *cr = value;
 
-  free_matching_requests(cr->client,
-                         pid,
-                         cr);
+  free_matching_requests (cr->client,
+                          pid,
+                          cr);
   return GNUNET_OK;
 }
 
@@ -205,14 +206,14 @@ free_request(void *cls,
  * Shutdown connectivity subsystem.
  */
 void
-GAS_connectivity_done()
+GAS_connectivity_done ()
 {
-  GAS_plugin_solver_lock();
-  GNUNET_CONTAINER_multipeermap_iterate(connection_requests,
-                                        &free_request,
-                                        NULL);
-  GAS_plugin_solver_unlock();
-  GNUNET_CONTAINER_multipeermap_destroy(connection_requests);
+  GAS_plugin_solver_lock ();
+  GNUNET_CONTAINER_multipeermap_iterate (connection_requests,
+                                         &free_request,
+                                         NULL);
+  GAS_plugin_solver_unlock ();
+  GNUNET_CONTAINER_multipeermap_destroy (connection_requests);
   connection_requests = NULL;
 }
 
diff --git a/src/ats/gnunet-service-ats_connectivity.h b/src/ats/gnunet-service-ats_connectivity.h
index 98d84b44a..39453dfc8 100644
--- a/src/ats/gnunet-service-ats_connectivity.h
+++ b/src/ats/gnunet-service-ats_connectivity.h
@@ -38,8 +38,8 @@
  * @return #GNUNET_YES if so, #GNUNET_NO if not
  */
 unsigned int
-GAS_connectivity_has_peer(void *cls,
-                          const struct GNUNET_PeerIdentity *peer);
+GAS_connectivity_has_peer (void *cls,
+                           const struct GNUNET_PeerIdentity *peer);
 
 
 /**
@@ -49,8 +49,8 @@ GAS_connectivity_has_peer(void *cls,
  * @param msg the request message
  */
 void
-GAS_handle_request_address(struct GNUNET_SERVICE_Client *client,
-                           const struct RequestAddressMessage *msg);
+GAS_handle_request_address (struct GNUNET_SERVICE_Client *client,
+                            const struct RequestAddressMessage *msg);
 
 
 /**
@@ -60,8 +60,8 @@ GAS_handle_request_address(struct GNUNET_SERVICE_Client *client,
  * @param msg the request message
  */
 void
-GAS_handle_request_address_cancel(struct GNUNET_SERVICE_Client *client,
-                                  const struct RequestAddressMessage *msg);
+GAS_handle_request_address_cancel (struct GNUNET_SERVICE_Client *client,
+                                   const struct RequestAddressMessage *msg);
 
 
 /**
@@ -71,21 +71,21 @@ GAS_handle_request_address_cancel(struct GNUNET_SERVICE_Client *client,
  * @param client handle of the (now dead) client
  */
 void
-GAS_connectivity_remove_client(struct GNUNET_SERVICE_Client *client);
+GAS_connectivity_remove_client (struct GNUNET_SERVICE_Client *client);
 
 
 /**
  * Initialize connectivity subsystem.
  */
 void
-GAS_connectivity_init(void);
+GAS_connectivity_init (void);
 
 
 /**
  * Shutdown connectivity subsystem.
  */
 void
-GAS_connectivity_done(void);
+GAS_connectivity_done (void);
 
 
 #endif
diff --git a/src/ats/gnunet-service-ats_normalization.c b/src/ats/gnunet-service-ats_normalization.c
index fa2b37425..36584e944 100644
--- a/src/ats/gnunet-service-ats_normalization.c
+++ b/src/ats/gnunet-service-ats_normalization.c
@@ -31,13 +31,14 @@
 #include "gnunet-service-ats_normalization.h"
 #include "gnunet-service-ats_plugins.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-normalization", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-normalization", __VA_ARGS__)
 
 
 /**
  * Range information for normalization of quality properties.
  */
-struct PropertyRange {
+struct PropertyRange
+{
   /**
    * Minimum value we see for this property across all addresses.
    */
@@ -64,8 +65,8 @@ static struct PropertyRange property_range;
  * @param ni normalization information to update
  */
 static void
-update_avg(uint64_t current_val,
-           struct GAS_NormalizationInfo *ni)
+update_avg (uint64_t current_val,
+            struct GAS_NormalizationInfo *ni)
 {
   double sum;
   uint32_t count;
@@ -77,13 +78,13 @@ update_avg(uint64_t current_val,
   count = 0;
   sum = 0.0;
   for (c1 = 0; c1 < GAS_normalization_queue_length; c1++)
+  {
+    if (UINT64_MAX != ni->atsi_abs[c1])
     {
-      if (UINT64_MAX != ni->atsi_abs[c1])
-        {
-          count++;
-          sum += (double)ni->atsi_abs[c1];
-        }
+      count++;
+      sum += (double) ni->atsi_abs[c1];
     }
+  }
   if (0 == count)
     ni->avg = current_val; /* must be UINT64_MAX */
   else
@@ -102,29 +103,29 @@ update_avg(uint64_t current_val,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-find_min_max_it(void *cls,
-                const struct GNUNET_PeerIdentity *h,
-                void *k)
+find_min_max_it (void *cls,
+                 const struct GNUNET_PeerIdentity *h,
+                 void *k)
 {
   struct PropertyRange *pr = cls;
   const struct ATS_Address *a = k;
 
-  pr->max.utilization_out = GNUNET_MAX(pr->max.utilization_out,
-                                       a->properties.utilization_out);
-  pr->max.utilization_in = GNUNET_MAX(pr->max.utilization_in,
-                                      a->properties.utilization_in);
-  pr->max.distance = GNUNET_MAX(pr->max.distance,
-                                a->properties.distance);
-  pr->max.delay = GNUNET_TIME_relative_max(pr->max.delay,
-                                           a->properties.delay);
-  pr->min.utilization_out = GNUNET_MIN(pr->min.utilization_out,
-                                       a->properties.utilization_out);
-  pr->min.utilization_in = GNUNET_MIN(pr->min.utilization_in,
-                                      a->properties.utilization_in);
-  pr->min.distance = GNUNET_MIN(pr->min.distance,
-                                a->properties.distance);
-  pr->min.delay = GNUNET_TIME_relative_min(pr->min.delay,
-                                           a->properties.delay);
+  pr->max.utilization_out = GNUNET_MAX (pr->max.utilization_out,
+                                        a->properties.utilization_out);
+  pr->max.utilization_in = GNUNET_MAX (pr->max.utilization_in,
+                                       a->properties.utilization_in);
+  pr->max.distance = GNUNET_MAX (pr->max.distance,
+                                 a->properties.distance);
+  pr->max.delay = GNUNET_TIME_relative_max (pr->max.delay,
+                                            a->properties.delay);
+  pr->min.utilization_out = GNUNET_MIN (pr->min.utilization_out,
+                                        a->properties.utilization_out);
+  pr->min.utilization_in = GNUNET_MIN (pr->min.utilization_in,
+                                       a->properties.utilization_in);
+  pr->min.distance = GNUNET_MIN (pr->min.distance,
+                                 a->properties.distance);
+  pr->min.delay = GNUNET_TIME_relative_min (pr->min.delay,
+                                            a->properties.delay);
   return GNUNET_OK;
 }
 
@@ -138,13 +139,13 @@ find_min_max_it(void *cls,
  * @param ni normalization information to update
  */
 static void
-update_norm(uint64_t min,
-            uint64_t max,
-            struct GAS_NormalizationInfo *ni)
+update_norm (uint64_t min,
+             uint64_t max,
+             struct GAS_NormalizationInfo *ni)
 {
   /* max - 2 * min + avg_value / (max - min) */
   if (min < max)
-    ni->norm = DEFAULT_REL_QUALITY + (ni->avg - min) / (double)(max - min);
+    ni->norm = DEFAULT_REL_QUALITY + (ni->avg - min) / (double) (max - min);
   else
     ni->norm = DEFAULT_REL_QUALITY;
 }
@@ -162,24 +163,24 @@ update_norm(uint64_t min,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-normalize_address(void *cls,
-                  const struct GNUNET_PeerIdentity *key,
-                  void *value)
+normalize_address (void *cls,
+                   const struct GNUNET_PeerIdentity *key,
+                   void *value)
 {
   struct ATS_Address *address = value;
 
-  update_norm(property_range.min.delay.rel_value_us,
-              property_range.max.delay.rel_value_us,
-              &address->norm_delay);
-  update_norm(property_range.min.distance,
-              property_range.max.distance,
-              &address->norm_distance);
-  update_norm(property_range.min.utilization_in,
-              property_range.max.utilization_in,
-              &address->norm_utilization_in);
-  update_norm(property_range.min.utilization_out,
-              property_range.max.utilization_out,
-              &address->norm_utilization_out);
+  update_norm (property_range.min.delay.rel_value_us,
+               property_range.max.delay.rel_value_us,
+               &address->norm_delay);
+  update_norm (property_range.min.distance,
+               property_range.max.distance,
+               &address->norm_distance);
+  update_norm (property_range.min.utilization_in,
+               property_range.max.utilization_in,
+               &address->norm_utilization_in);
+  update_norm (property_range.min.utilization_out,
+               property_range.max.utilization_out,
+               &address->norm_utilization_out);
   return GNUNET_OK;
 }
 
@@ -193,13 +194,13 @@ normalize_address(void *cls,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-notify_change(void *cls,
-              const struct GNUNET_PeerIdentity *key,
-              void *value)
+notify_change (void *cls,
+               const struct GNUNET_PeerIdentity *key,
+               void *value)
 {
   struct ATS_Address *address = value;
 
-  GAS_plugin_notify_property_changed(address);
+  GAS_plugin_notify_property_changed (address);
   return GNUNET_OK;
 }
 
@@ -211,9 +212,9 @@ notify_change(void *cls,
  * @param pr range to initialize
  */
 static void
-init_range(struct PropertyRange *pr)
+init_range (struct PropertyRange *pr)
 {
-  memset(pr, 0, sizeof(struct PropertyRange));
+  memset (pr, 0, sizeof(struct PropertyRange));
   pr->min.utilization_out = UINT32_MAX;
   pr->min.utilization_in = UINT32_MAX;
   pr->min.distance = UINT32_MAX;
@@ -227,51 +228,51 @@ init_range(struct PropertyRange *pr)
  * @param address the address to update
  */
 void
-GAS_normalization_update_property(struct ATS_Address *address)
+GAS_normalization_update_property (struct ATS_Address *address)
 {
   const struct GNUNET_ATS_Properties *prop = &address->properties;
   struct PropertyRange range;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Updating properties for peer `%s'\n",
-      GNUNET_i2s(&address->peer));
-  GAS_plugin_solver_lock();
-  update_avg(prop->delay.rel_value_us,
-             &address->norm_delay);
-  update_avg(prop->distance,
-             &address->norm_distance);
-  update_avg(prop->utilization_in,
-             &address->norm_utilization_in);
-  update_avg(prop->utilization_in,
-             &address->norm_utilization_out);
-
-  init_range(&range);
-  GNUNET_CONTAINER_multipeermap_iterate(GSA_addresses,
-                                        &find_min_max_it,
-                                        &range);
-  if (0 != GNUNET_memcmp(&range,
-                         &property_range))
-    {
-      /* limits changed, (re)normalize all addresses */
-      property_range = range;
-      GNUNET_CONTAINER_multipeermap_iterate(GSA_addresses,
-                                            &normalize_address,
-                                            NULL);
-      GNUNET_CONTAINER_multipeermap_iterate(GSA_addresses,
-                                            &notify_change,
-                                            NULL);
-    }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Updating properties for peer `%s'\n",
+       GNUNET_i2s (&address->peer));
+  GAS_plugin_solver_lock ();
+  update_avg (prop->delay.rel_value_us,
+              &address->norm_delay);
+  update_avg (prop->distance,
+              &address->norm_distance);
+  update_avg (prop->utilization_in,
+              &address->norm_utilization_in);
+  update_avg (prop->utilization_in,
+              &address->norm_utilization_out);
+
+  init_range (&range);
+  GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                         &find_min_max_it,
+                                         &range);
+  if (0 != GNUNET_memcmp (&range,
+                          &property_range))
+  {
+    /* limits changed, (re)normalize all addresses */
+    property_range = range;
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                           &normalize_address,
+                                           NULL);
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                           &notify_change,
+                                           NULL);
+  }
   else
-    {
-      /* renormalize just this one address */
-      normalize_address(NULL,
-                        &address->peer,
-                        address);
-      notify_change(NULL,
-                    &address->peer,
-                    address);
-    }
-  GAS_plugin_solver_unlock();
+  {
+    /* renormalize just this one address */
+    normalize_address (NULL,
+                       &address->peer,
+                       address);
+    notify_change (NULL,
+                   &address->peer,
+                   address);
+  }
+  GAS_plugin_solver_unlock ();
 }
 
 
@@ -279,9 +280,9 @@ GAS_normalization_update_property(struct ATS_Address *address)
  * Start the normalization component
  */
 void
-GAS_normalization_start()
+GAS_normalization_start ()
 {
-  init_range(&property_range);
+  init_range (&property_range);
 }
 
 
@@ -289,7 +290,7 @@ GAS_normalization_start()
  * Stop the normalization component and free all items
  */
 void
-GAS_normalization_stop()
+GAS_normalization_stop ()
 {
   /* nothing to do */
 }
diff --git a/src/ats/gnunet-service-ats_normalization.h b/src/ats/gnunet-service-ats_normalization.h
index 57bcf49f4..9c02586c2 100644
--- a/src/ats/gnunet-service-ats_normalization.h
+++ b/src/ats/gnunet-service-ats_normalization.h
@@ -40,21 +40,21 @@
  * @param address the address to update
  */
 void
-GAS_normalization_update_property(struct ATS_Address *address);
+GAS_normalization_update_property (struct ATS_Address *address);
 
 
 /**
  * Start the normalization component
  */
 void
-GAS_normalization_start(void);
+GAS_normalization_start (void);
 
 
 /**
  * Stop the normalization component and free all items
  */
 void
-GAS_normalization_stop(void);
+GAS_normalization_stop (void);
 
 #endif
 /* end of gnunet-service-ats_normalization.h */
diff --git a/src/ats/gnunet-service-ats_performance.c b/src/ats/gnunet-service-ats_performance.c
index 16d0777de..441c6610e 100644
--- a/src/ats/gnunet-service-ats_performance.c
+++ b/src/ats/gnunet-service-ats_performance.c
@@ -63,64 +63,64 @@ static struct GNUNET_NotificationContext *nc_pic;
  * @param bandwidth_in assigned inbound bandwidth
  */
 static void
-notify_client(struct GNUNET_SERVICE_Client *client,
-              const struct GNUNET_PeerIdentity *peer,
-              const char *plugin_name,
-              const void *plugin_addr,
-              size_t plugin_addr_len,
-              int active,
-              const struct GNUNET_ATS_Properties *prop,
-              enum GNUNET_HELLO_AddressInfo local_address_info,
-              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+notify_client (struct GNUNET_SERVICE_Client *client,
+               const struct GNUNET_PeerIdentity *peer,
+               const char *plugin_name,
+               const void *plugin_addr,
+               size_t plugin_addr_len,
+               int active,
+               const struct GNUNET_ATS_Properties *prop,
+               enum GNUNET_HELLO_AddressInfo local_address_info,
+               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
   struct PeerInformationMessage *msg;
-  size_t plugin_name_length = strlen(plugin_name) + 1;
+  size_t plugin_name_length = strlen (plugin_name) + 1;
   size_t msize =
-    sizeof(struct PeerInformationMessage) +
-    plugin_addr_len +
-    plugin_name_length;
+    sizeof(struct PeerInformationMessage)
+    + plugin_addr_len
+    + plugin_name_length;
   char buf[msize] GNUNET_ALIGN;
   char *addrp;
 
   if (NULL != prop)
-    GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
-  GNUNET_assert(msize < GNUNET_MAX_MESSAGE_SIZE);
-  msg = (struct PeerInformationMessage *)buf;
-  msg->header.size = htons(msize);
-  msg->header.type = htons(GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION);
-  msg->id = htonl(0);
+    GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
+  GNUNET_assert (msize < GNUNET_MAX_MESSAGE_SIZE);
+  msg = (struct PeerInformationMessage *) buf;
+  msg->header.size = htons (msize);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION);
+  msg->id = htonl (0);
   msg->peer = *peer;
-  msg->address_length = htons(plugin_addr_len);
-  msg->address_active = ntohl((uint32_t)active);
-  msg->plugin_name_length = htons(plugin_name_length);
+  msg->address_length = htons (plugin_addr_len);
+  msg->address_active = ntohl ((uint32_t) active);
+  msg->plugin_name_length = htons (plugin_name_length);
   msg->bandwidth_out = bandwidth_out;
   msg->bandwidth_in = bandwidth_in;
   if (NULL != prop)
-    GNUNET_ATS_properties_hton(&msg->properties,
-                               prop);
+    GNUNET_ATS_properties_hton (&msg->properties,
+                                prop);
   else
-    memset(&msg->properties,
-           0,
-           sizeof(struct GNUNET_ATS_Properties));
-  msg->address_local_info = htonl(local_address_info);
-  addrp = (char *)&msg[1];
-  GNUNET_memcpy(addrp, plugin_addr, plugin_addr_len);
-  strcpy(&addrp[plugin_addr_len], plugin_name);
+    memset (&msg->properties,
+            0,
+            sizeof(struct GNUNET_ATS_Properties));
+  msg->address_local_info = htonl (local_address_info);
+  addrp = (char *) &msg[1];
+  GNUNET_memcpy (addrp, plugin_addr, plugin_addr_len);
+  strcpy (&addrp[plugin_addr_len], plugin_name);
   if (NULL == client)
-    {
-      GNUNET_notification_context_broadcast(nc_pic,
-                                            &msg->header,
-                                            GNUNET_YES);
-    }
+  {
+    GNUNET_notification_context_broadcast (nc_pic,
+                                           &msg->header,
+                                           GNUNET_YES);
+  }
   else
-    {
-      struct GNUNET_MQ_Envelope *env;
+  {
+    struct GNUNET_MQ_Envelope *env;
 
-      env = GNUNET_MQ_msg_copy(&msg->header);
-      GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client),
-                     env);
-    }
+    env = GNUNET_MQ_msg_copy (&msg->header);
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                    env);
+  }
 }
 
 
@@ -142,32 +142,35 @@ notify_client(struct GNUNET_SERVICE_Client *client,
  * @param bandwidth_in assigned inbound bandwidth
  */
 void
-GAS_performance_notify_all_clients(const struct GNUNET_PeerIdentity *peer,
-                                   const char *plugin_name,
-                                   const void *plugin_addr,
-                                   size_t plugin_addr_len,
-                                   int active,
-                                   const struct GNUNET_ATS_Properties *prop,
-                                   enum GNUNET_HELLO_AddressInfo local_address_info,
-                                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+GAS_performance_notify_all_clients (const struct GNUNET_PeerIdentity *peer,
+                                    const char *plugin_name,
+                                    const void *plugin_addr,
+                                    size_t plugin_addr_len,
+                                    int active,
+                                    const struct GNUNET_ATS_Properties *prop,
+                                    enum GNUNET_HELLO_AddressInfo
+                                    local_address_info,
+                                    struct GNUNET_BANDWIDTH_Value32NBO
+                                    bandwidth_out,
+                                    struct GNUNET_BANDWIDTH_Value32NBO
+                                    bandwidth_in)
 {
-  GNUNET_break((NULL == prop) ||
-               (GNUNET_NT_UNSPECIFIED != prop->scope));
-  notify_client(NULL,
-                peer,
-                plugin_name,
-                plugin_addr,
-                plugin_addr_len,
-                active,
-                prop,
-                local_address_info,
-                bandwidth_out,
-                bandwidth_in);
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# performance updates given to clients",
-                           1,
-                           GNUNET_NO);
+  GNUNET_break ((NULL == prop) ||
+                (GNUNET_NT_UNSPECIFIED != prop->scope));
+  notify_client (NULL,
+                 peer,
+                 plugin_name,
+                 plugin_addr,
+                 plugin_addr_len,
+                 active,
+                 prop,
+                 local_address_info,
+                 bandwidth_out,
+                 bandwidth_in);
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# performance updates given to clients",
+                            1,
+                            GNUNET_NO);
 }
 
 
@@ -186,38 +189,38 @@ GAS_performance_notify_all_clients(const struct GNUNET_PeerIdentity *peer,
  * @param bandwidth_in current inbound bandwidth assigned to address
  */
 static void
-peerinfo_it(void *cls,
-            const struct GNUNET_PeerIdentity *id,
-            const char *plugin_name,
-            const void *plugin_addr,
-            size_t plugin_addr_len,
-            int active,
-            const struct GNUNET_ATS_Properties *prop,
-            enum GNUNET_HELLO_AddressInfo local_address_info,
-            struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-            struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+peerinfo_it (void *cls,
+             const struct GNUNET_PeerIdentity *id,
+             const char *plugin_name,
+             const void *plugin_addr,
+             size_t plugin_addr_len,
+             int active,
+             const struct GNUNET_ATS_Properties *prop,
+             enum GNUNET_HELLO_AddressInfo local_address_info,
+             struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+             struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
   if (NULL == id)
     return;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Callback for peer `%s' plugin `%s' BW out %u, BW in %u \n",
-             GNUNET_i2s(id),
-             plugin_name,
-             (unsigned int)ntohl(bandwidth_out.value__),
-             (unsigned int)ntohl(bandwidth_in.value__));
-  GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
-  notify_client(client,
-                id,
-                plugin_name,
-                plugin_addr,
-                plugin_addr_len,
-                active,
-                prop,
-                local_address_info,
-                bandwidth_out,
-                bandwidth_in);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Callback for peer `%s' plugin `%s' BW out %u, BW in %u \n",
+              GNUNET_i2s (id),
+              plugin_name,
+              (unsigned int) ntohl (bandwidth_out.value__),
+              (unsigned int) ntohl (bandwidth_in.value__));
+  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
+  notify_client (client,
+                 id,
+                 plugin_name,
+                 plugin_addr,
+                 plugin_addr_len,
+                 active,
+                 prop,
+                 local_address_info,
+                 bandwidth_out,
+                 bandwidth_in);
 }
 
 
@@ -228,25 +231,25 @@ peerinfo_it(void *cls,
  * @param flag flag specifying the type of the client
  */
 void
-GAS_performance_add_client(struct GNUNET_SERVICE_Client *client,
-                           enum StartFlag flag)
+GAS_performance_add_client (struct GNUNET_SERVICE_Client *client,
+                            enum StartFlag flag)
 {
   struct GNUNET_MQ_Handle *mq;
 
-  mq = GNUNET_SERVICE_client_get_mq(client);
+  mq = GNUNET_SERVICE_client_get_mq (client);
   if (START_FLAG_PERFORMANCE_WITH_PIC == flag)
-    {
-      GNUNET_notification_context_add(nc_pic,
-                                      mq);
-      GAS_addresses_get_peer_info(NULL,
-                                  &peerinfo_it,
-                                  client);
-    }
+  {
+    GNUNET_notification_context_add (nc_pic,
+                                     mq);
+    GAS_addresses_get_peer_info (NULL,
+                                 &peerinfo_it,
+                                 client);
+  }
   else
-    {
-      GNUNET_notification_context_add(nc_no_pic,
-                                      mq);
-    }
+  {
+    GNUNET_notification_context_add (nc_no_pic,
+                                     mq);
+  }
 }
 
 
@@ -256,10 +259,10 @@ GAS_performance_add_client(struct GNUNET_SERVICE_Client *client,
  * @param server handle to our server
  */
 void
-GAS_performance_init()
+GAS_performance_init ()
 {
-  nc_no_pic = GNUNET_notification_context_create(32);
-  nc_pic = GNUNET_notification_context_create(32);
+  nc_no_pic = GNUNET_notification_context_create (32);
+  nc_pic = GNUNET_notification_context_create (32);
 }
 
 
@@ -267,11 +270,11 @@ GAS_performance_init()
  * Shutdown performance subsystem.
  */
 void
-GAS_performance_done()
+GAS_performance_done ()
 {
-  GNUNET_notification_context_destroy(nc_no_pic);
+  GNUNET_notification_context_destroy (nc_no_pic);
   nc_no_pic = NULL;
-  GNUNET_notification_context_destroy(nc_pic);
+  GNUNET_notification_context_destroy (nc_pic);
   nc_pic = NULL;
 }
 
diff --git a/src/ats/gnunet-service-ats_performance.h b/src/ats/gnunet-service-ats_performance.h
index 3d5de0d85..292c27c95 100644
--- a/src/ats/gnunet-service-ats_performance.h
+++ b/src/ats/gnunet-service-ats_performance.h
@@ -50,15 +50,18 @@
  * @param bandwidth_in assigned inbound bandwidth
  */
 void
-GAS_performance_notify_all_clients(const struct GNUNET_PeerIdentity *peer,
-                                   const char *plugin_name,
-                                   const void *plugin_addr,
-                                   size_t plugin_addr_len,
-                                   int active,
-                                   const struct GNUNET_ATS_Properties *prop,
-                                   enum GNUNET_HELLO_AddressInfo local_address_info,
-                                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in);
+GAS_performance_notify_all_clients (const struct GNUNET_PeerIdentity *peer,
+                                    const char *plugin_name,
+                                    const void *plugin_addr,
+                                    size_t plugin_addr_len,
+                                    int active,
+                                    const struct GNUNET_ATS_Properties *prop,
+                                    enum GNUNET_HELLO_AddressInfo
+                                    local_address_info,
+                                    struct GNUNET_BANDWIDTH_Value32NBO
+                                    bandwidth_out,
+                                    struct GNUNET_BANDWIDTH_Value32NBO
+                                    bandwidth_in);
 
 
 /**
@@ -68,8 +71,8 @@ GAS_performance_notify_all_clients(const struct GNUNET_PeerIdentity *peer,
  * @param flag flag specifying the type of the client
  */
 void
-GAS_performance_add_client(struct GNUNET_SERVICE_Client *client,
-                           enum StartFlag flag);
+GAS_performance_add_client (struct GNUNET_SERVICE_Client *client,
+                            enum StartFlag flag);
 
 
 /**
@@ -79,14 +82,14 @@ GAS_performance_add_client(struct GNUNET_SERVICE_Client *client,
  * @param addresses the address handle to use
  */
 void
-GAS_performance_init(void);
+GAS_performance_init (void);
 
 
 /**
  * Shutdown performance subsystem.
  */
 void
-GAS_performance_done(void);
+GAS_performance_done (void);
 
 
 #endif
diff --git a/src/ats/gnunet-service-ats_plugins.c b/src/ats/gnunet-service-ats_plugins.c
index 274f89e7a..d8d6be11d 100644
--- a/src/ats/gnunet-service-ats_plugins.c
+++ b/src/ats/gnunet-service-ats_plugins.c
@@ -59,14 +59,14 @@ static char *plugin;
  * @param pref_rel the new relative preference value
  */
 void
-GAS_plugin_notify_preference_changed(const struct GNUNET_PeerIdentity *peer,
-                                     enum GNUNET_ATS_PreferenceKind kind,
-                                     double pref_rel)
+GAS_plugin_notify_preference_changed (const struct GNUNET_PeerIdentity *peer,
+                                      enum GNUNET_ATS_PreferenceKind kind,
+                                      double pref_rel)
 {
-  sf->s_pref(sf->cls,
-             peer,
-             kind,
-             pref_rel);
+  sf->s_pref (sf->cls,
+              peer,
+              kind,
+              pref_rel);
 }
 
 
@@ -76,10 +76,10 @@ GAS_plugin_notify_preference_changed(const struct GNUNET_PeerIdentity *peer,
  * @param address the peer for which a property changed
  */
 void
-GAS_plugin_notify_property_changed(struct ATS_Address *address)
+GAS_plugin_notify_property_changed (struct ATS_Address *address)
 {
-  sf->s_address_update_property(sf->cls,
-                                address);
+  sf->s_address_update_property (sf->cls,
+                                 address);
 }
 
 
@@ -92,116 +92,116 @@ GAS_plugin_notify_property_changed(struct ATS_Address *address)
  * @param add additional information
  */
 static void
-solver_info_cb(void *cls,
-               enum GAS_Solver_Operation op,
-               enum GAS_Solver_Status status,
-               enum GAS_Solver_Additional_Information add)
+solver_info_cb (void *cls,
+                enum GAS_Solver_Operation op,
+                enum GAS_Solver_Status status,
+                enum GAS_Solver_Additional_Information add)
 {
   const char *add_info;
 
   switch (add)
-    {
-    case GAS_INFO_NONE:
-      add_info = "GAS_INFO_NONE";
-      break;
-
-    case GAS_INFO_FULL:
-      add_info = "GAS_INFO_MLP_FULL";
-      break;
-
-    case GAS_INFO_UPDATED:
-      add_info = "GAS_INFO_MLP_UPDATED";
-      break;
-
-    case GAS_INFO_PROP_ALL:
-      add_info = "GAS_INFO_PROP_ALL";
-      break;
-
-    case GAS_INFO_PROP_SINGLE:
-      add_info = "GAS_INFO_PROP_SINGLE";
-      break;
-
-    default:
-      add_info = "INVALID";
-      break;
-    }
+  {
+  case GAS_INFO_NONE:
+    add_info = "GAS_INFO_NONE";
+    break;
+
+  case GAS_INFO_FULL:
+    add_info = "GAS_INFO_MLP_FULL";
+    break;
+
+  case GAS_INFO_UPDATED:
+    add_info = "GAS_INFO_MLP_UPDATED";
+    break;
+
+  case GAS_INFO_PROP_ALL:
+    add_info = "GAS_INFO_PROP_ALL";
+    break;
+
+  case GAS_INFO_PROP_SINGLE:
+    add_info = "GAS_INFO_PROP_SINGLE";
+    break;
+
+  default:
+    add_info = "INVALID";
+    break;
+  }
   switch (op)
-    {
-    case GAS_OP_SOLVE_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s' `%s'\n",
-                 "GAS_OP_SOLVE_START",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL",
-                 add_info);
-      return;
-
-    case GAS_OP_SOLVE_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_STOP",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_SETUP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_SETUP_START",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_SETUP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_SETUP_STOP",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_MLP_LP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_LP_START",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_MLP_LP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_LP_STOP",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_MLP_MLP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_MLP_START",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_MLP_MLP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_MLP_STOP",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Solver notifies `%s' with result `%s'\n",
-                 "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
-                 (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    default:
-      GNUNET_break(0);
-      break;
-    }
+  {
+  case GAS_OP_SOLVE_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s' `%s'\n",
+                "GAS_OP_SOLVE_START",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL",
+                add_info);
+    return;
+
+  case GAS_OP_SOLVE_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_STOP",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_SETUP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_SETUP_START",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_SETUP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_SETUP_STOP",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_MLP_LP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_LP_START",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_MLP_LP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_LP_STOP",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_MLP_MLP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_MLP_START",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_MLP_MLP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_MLP_STOP",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
+                (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
+    return;
+
+  default:
+    GNUNET_break (0);
+    break;
+  }
 }
 
 
@@ -212,69 +212,74 @@ solver_info_cb(void *cls,
  * @param address the address with changes
  */
 static void
-bandwidth_changed_cb(void *cls,
-                     struct ATS_Address *address)
+bandwidth_changed_cb (void *cls,
+                      struct ATS_Address *address)
 {
   long long diff_out;
   long long diff_in;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Bandwidth assignment changed for peer %s to %u/%u\n",
-             GNUNET_i2s(&address->peer),
-             (unsigned int)address->assigned_bw_in,
-             (unsigned int)address->assigned_bw_out);
-  GAS_reservations_set_bandwidth(&address->peer,
-                                 GNUNET_BANDWIDTH_value_init(address->assigned_bw_in));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Bandwidth assignment changed for peer %s to %u/%u\n",
+              GNUNET_i2s (&address->peer),
+              (unsigned int) address->assigned_bw_in,
+              (unsigned int) address->assigned_bw_out);
+  GAS_reservations_set_bandwidth (&address->peer,
+                                  GNUNET_BANDWIDTH_value_init (
+                                    address->assigned_bw_in));
   /* Notify performance clients about changes to address */
-  GAS_performance_notify_all_clients(&address->peer,
-                                     address->plugin,
-                                     address->addr,
-                                     address->addr_len,
-                                     address->active,
-                                     &address->properties,
-                                     address->local_address_info,
-                                     GNUNET_BANDWIDTH_value_init(address->assigned_bw_out),
-                                     GNUNET_BANDWIDTH_value_init(address->assigned_bw_in));
+  GAS_performance_notify_all_clients (&address->peer,
+                                      address->plugin,
+                                      address->addr,
+                                      address->addr_len,
+                                      address->active,
+                                      &address->properties,
+                                      address->local_address_info,
+                                      GNUNET_BANDWIDTH_value_init (
+                                        address->assigned_bw_out),
+                                      GNUNET_BANDWIDTH_value_init (
+                                        address->assigned_bw_in));
 
   if ((0 == address->assigned_bw_in) &&
       (0 == address->assigned_bw_out))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Telling transport to disconnect peer `%s'\n",
-                 GNUNET_i2s(&address->peer));
-
-      /* Notify scheduling clients about suggestion */
-      GAS_scheduling_transmit_address_suggestion(&address->peer,
-                                                 address->session_id,
-                                                 GNUNET_BANDWIDTH_ZERO,
-                                                 GNUNET_BANDWIDTH_ZERO);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Telling transport to disconnect peer `%s'\n",
+                GNUNET_i2s (&address->peer));
+
+    /* Notify scheduling clients about suggestion */
+    GAS_scheduling_transmit_address_suggestion (&address->peer,
+                                                address->session_id,
+                                                GNUNET_BANDWIDTH_ZERO,
+                                                GNUNET_BANDWIDTH_ZERO);
+    return;
+  }
 
   /* Do bandwidth stability check */
-  diff_out = llabs((long long)address->assigned_bw_out -
-                   (long long)address->last_notified_bw_out);
-  diff_in = llabs((long long)address->assigned_bw_in -
-                  (long long)address->last_notified_bw_in);
-  if ((diff_out < htonl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__)) &&
-      (diff_in < htonl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Bandwidth change too small, not notifying client\n");
-      return;
-    }
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending bandwidth update for peer `%s': %u/%u\n",
-             GNUNET_i2s(&address->peer),
-             address->assigned_bw_out,
-             address->assigned_bw_out);
+  diff_out = llabs ((long long) address->assigned_bw_out
+                    - (long long) address->last_notified_bw_out);
+  diff_in = llabs ((long long) address->assigned_bw_in
+                   - (long long) address->last_notified_bw_in);
+  if ((diff_out < htonl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__)) &&
+      (diff_in < htonl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Bandwidth change too small, not notifying client\n");
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending bandwidth update for peer `%s': %u/%u\n",
+              GNUNET_i2s (&address->peer),
+              address->assigned_bw_out,
+              address->assigned_bw_out);
 
   /* *Notify scheduling clients about suggestion */
-  GAS_scheduling_transmit_address_suggestion(&address->peer,
-                                             address->session_id,
-                                             GNUNET_BANDWIDTH_value_init(address->assigned_bw_out),
-                                             GNUNET_BANDWIDTH_value_init(address->assigned_bw_in));
+  GAS_scheduling_transmit_address_suggestion (&address->peer,
+                                              address->session_id,
+                                              GNUNET_BANDWIDTH_value_init (
+                                                address->assigned_bw_out),
+                                              GNUNET_BANDWIDTH_value_init (
+                                                address->assigned_bw_in));
 
   address->last_notified_bw_out = address->assigned_bw_out;
   address->last_notified_bw_in = address->assigned_bw_in;
@@ -290,48 +295,49 @@ bandwidth_changed_cb(void *cls,
  * @return numeric quota value to use
  */
 static unsigned long long
-parse_quota(const char *quota_str,
-            const char *direction,
-            enum GNUNET_NetworkType network)
+parse_quota (const char *quota_str,
+             const char *direction,
+             enum GNUNET_NetworkType network)
 {
   int res;
   unsigned long long ret;
 
   res = GNUNET_NO;
-  if (0 == strcmp(quota_str, GNUNET_ATS_MaxBandwidthString))
-    {
-      ret = GNUNET_ATS_MaxBandwidth;
-      res = GNUNET_YES;
-    }
+  if (0 == strcmp (quota_str, GNUNET_ATS_MaxBandwidthString))
+  {
+    ret = GNUNET_ATS_MaxBandwidth;
+    res = GNUNET_YES;
+  }
   if ((GNUNET_NO == res) &&
       (GNUNET_OK ==
-       GNUNET_STRINGS_fancy_size_to_bytes(quota_str,
-                                          &ret)))
+       GNUNET_STRINGS_fancy_size_to_bytes (quota_str,
+                                           &ret)))
     res = GNUNET_YES;
   if ((GNUNET_NO == res) &&
       (1 ==
-       sscanf(quota_str,
-              "%llu",
-              &ret)))
+       sscanf (quota_str,
+               "%llu",
+               &ret)))
     res = GNUNET_YES;
   if (GNUNET_NO == res)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Could not load %s quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-                 direction,
-                 GNUNET_NT_to_string(network),
-                 quota_str,
-                 (unsigned long long)GNUNET_ATS_DefaultBandwidth);
-      ret = GNUNET_ATS_DefaultBandwidth;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ (
+                  "Could not load %s quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                direction,
+                GNUNET_NT_to_string (network),
+                quota_str,
+                (unsigned long long) GNUNET_ATS_DefaultBandwidth);
+    ret = GNUNET_ATS_DefaultBandwidth;
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("%s quota configured for network `%s' is %llu\n"),
-                 direction,
-                 GNUNET_NT_to_string(network),
-                 ret);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("%s quota configured for network `%s' is %llu\n"),
+                direction,
+                GNUNET_NT_to_string (network),
+                ret);
+  }
   return ret;
 }
 
@@ -346,39 +352,40 @@ parse_quota(const char *quota_str,
  * @return quota to apply
  */
 static unsigned long long
-load_quota(const struct GNUNET_CONFIGURATION_Handle *cfg,
-           enum GNUNET_NetworkType type,
-           const char *direction)
+load_quota (const struct GNUNET_CONFIGURATION_Handle *cfg,
+            enum GNUNET_NetworkType type,
+            const char *direction)
 {
   char *entry;
   char *quota_str;
   unsigned long long ret;
 
-  GNUNET_asprintf(&entry,
-                  "%s_QUOTA_%s",
-                  GNUNET_NT_to_string(type),
-                  direction);
+  GNUNET_asprintf (&entry,
+                   "%s_QUOTA_%s",
+                   GNUNET_NT_to_string (type),
+                   direction);
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_string(cfg,
-                                            "ats",
-                                            entry,
-                                            &quota_str))
-    {
-      ret = parse_quota(quota_str,
-                        direction,
-                        type);
-      GNUNET_free(quota_str);
-    }
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "ats",
+                                             entry,
+                                             &quota_str))
+  {
+    ret = parse_quota (quota_str,
+                       direction,
+                       type);
+    GNUNET_free (quota_str);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("No %s-quota configured for network `%s', assigning default bandwidth %llu\n"),
-                 direction,
-                 GNUNET_NT_to_string(type),
-                 (unsigned long long)GNUNET_ATS_DefaultBandwidth);
-      ret = GNUNET_ATS_DefaultBandwidth;
-    }
-  GNUNET_free(entry);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ (
+                  "No %s-quota configured for network `%s', assigning default bandwidth %llu\n"),
+                direction,
+                GNUNET_NT_to_string (type),
+                (unsigned long long) GNUNET_ATS_DefaultBandwidth);
+    ret = GNUNET_ATS_DefaultBandwidth;
+  }
+  GNUNET_free (entry);
   return ret;
 }
 
@@ -393,27 +400,27 @@ load_quota(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return number of networks loaded
  */
 static unsigned int
-load_quotas(const struct GNUNET_CONFIGURATION_Handle *cfg,
-            unsigned long long *out_dest,
-            unsigned long long *in_dest,
-            int dest_length)
+load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
+             unsigned long long *out_dest,
+             unsigned long long *in_dest,
+             int dest_length)
 {
   unsigned int c;
 
   for (c = 0; (c < GNUNET_NT_COUNT) && (c < dest_length); c++)
-    {
-      in_dest[c] = load_quota(cfg,
+  {
+    in_dest[c] = load_quota (cfg,
+                             c,
+                             "out");
+    out_dest[c] = load_quota (cfg,
                               c,
-                              "out");
-      out_dest[c] = load_quota(cfg,
-                               c,
-                               "in");
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Loaded quota for network `%s' (in/out): %llu %llu\n",
-                 GNUNET_NT_to_string(c),
-                 in_dest[c],
-                 out_dest[c]);
-    }
+                              "in");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Loaded quota for network `%s' (in/out): %llu %llu\n",
+                GNUNET_NT_to_string (c),
+                in_dest[c],
+                out_dest[c]);
+  }
   return c;
 }
 
@@ -426,21 +433,21 @@ load_quotas(const struct GNUNET_CONFIGURATION_Handle *cfg,
  *         solver plugin)
  */
 int
-GAS_plugin_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
+GAS_plugin_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *mode_str;
 
   /* Figure out configured solution method */
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string(cfg,
-                                            "ats",
-                                            "MODE",
-                                            &mode_str))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "No resource assignment method configured, using proportional approach\n");
-      mode_str = GNUNET_strdup("proportional");
-    }
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "ats",
+                                             "MODE",
+                                             &mode_str))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "No resource assignment method configured, using proportional approach\n");
+    mode_str = GNUNET_strdup ("proportional");
+  }
   env.cls = NULL;
   env.info_cb = &solver_info_cb;
   env.bandwidth_changed_cb = &bandwidth_changed_cb;
@@ -450,24 +457,24 @@ GAS_plugin_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
   env.stats = GSA_stats;
   env.addresses = GSA_addresses;
   env.network_count = GNUNET_NT_COUNT;
-  load_quotas(cfg,
-              env.out_quota,
-              env.in_quota,
-              GNUNET_NT_COUNT);
-  GNUNET_asprintf(&plugin,
-                  "libgnunet_plugin_ats_%s",
-                  mode_str);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Initializing solver `%s'\n",
-             mode_str);
-  GNUNET_free(mode_str);
-  if (NULL == (sf = GNUNET_PLUGIN_load(plugin, &env)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to initialize solver `%s'!\n"),
-                 plugin);
-      return GNUNET_SYSERR;
-    }
+  load_quotas (cfg,
+               env.out_quota,
+               env.in_quota,
+               GNUNET_NT_COUNT);
+  GNUNET_asprintf (&plugin,
+                   "libgnunet_plugin_ats_%s",
+                   mode_str);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initializing solver `%s'\n",
+              mode_str);
+  GNUNET_free (mode_str);
+  if (NULL == (sf = GNUNET_PLUGIN_load (plugin, &env)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to initialize solver `%s'!\n"),
+                plugin);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -476,12 +483,12 @@ GAS_plugin_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
  * Shutdown address subsystem.
  */
 void
-GAS_plugin_done()
+GAS_plugin_done ()
 {
-  GNUNET_PLUGIN_unload(plugin,
-                       sf);
+  GNUNET_PLUGIN_unload (plugin,
+                        sf);
   sf = NULL;
-  GNUNET_free(plugin);
+  GNUNET_free (plugin);
   plugin = NULL;
 }
 
@@ -493,11 +500,11 @@ GAS_plugin_done()
  * @param new_address the new address
  */
 void
-GAS_plugin_new_address(struct ATS_Address *new_address)
+GAS_plugin_new_address (struct ATS_Address *new_address)
 {
-  sf->s_add(sf->cls,
-            new_address,
-            new_address->properties.scope);  /* FIXME: remove 3rd arg here! */
+  sf->s_add (sf->cls,
+             new_address,
+             new_address->properties.scope); /* FIXME: remove 3rd arg here! */
 }
 
 
@@ -508,10 +515,10 @@ GAS_plugin_new_address(struct ATS_Address *new_address)
  * @param address address that was deleted
  */
 void
-GAS_plugin_delete_address(struct ATS_Address *address)
+GAS_plugin_delete_address (struct ATS_Address *address)
 {
-  sf->s_del(sf->cls,
-            address);
+  sf->s_del (sf->cls,
+             address);
 }
 
 
@@ -526,18 +533,18 @@ GAS_plugin_delete_address(struct ATS_Address *address)
  * @param score_abs degree of the appreciation
  */
 void
-GAS_plugin_notify_feedback(struct GNUNET_SERVICE_Client *application,
-                           const struct GNUNET_PeerIdentity *peer,
-                           const struct GNUNET_TIME_Relative scope,
-                           enum GNUNET_ATS_PreferenceKind kind,
-                           float score_abs)
+GAS_plugin_notify_feedback (struct GNUNET_SERVICE_Client *application,
+                            const struct GNUNET_PeerIdentity *peer,
+                            const struct GNUNET_TIME_Relative scope,
+                            enum GNUNET_ATS_PreferenceKind kind,
+                            float score_abs)
 {
-  sf->s_feedback(sf->cls,
-                 application,
-                 peer,
-                 scope,
-                 kind,
-                 score_abs);
+  sf->s_feedback (sf->cls,
+                  application,
+                  peer,
+                  scope,
+                  kind,
+                  score_abs);
 }
 
 
@@ -546,9 +553,9 @@ GAS_plugin_notify_feedback(struct GNUNET_SERVICE_Client *application,
  * happening in bulk right now.
  */
 void
-GAS_plugin_solver_lock()
+GAS_plugin_solver_lock ()
 {
-  sf->s_bulk_start(sf->cls);
+  sf->s_bulk_start (sf->cls);
 }
 
 
@@ -556,9 +563,9 @@ GAS_plugin_solver_lock()
  * Resume instant solving, we are done with the bulk state updates.
  */
 void
-GAS_plugin_solver_unlock()
+GAS_plugin_solver_unlock ()
 {
-  sf->s_bulk_stop(sf->cls);
+  sf->s_bulk_stop (sf->cls);
 }
 
 
@@ -569,10 +576,10 @@ GAS_plugin_solver_unlock()
  * @param pid identity of peer we now care about
  */
 void
-GAS_plugin_request_connect_start(const struct GNUNET_PeerIdentity *pid)
+GAS_plugin_request_connect_start (const struct GNUNET_PeerIdentity *pid)
 {
-  sf->s_get(sf->cls,
-            pid);
+  sf->s_get (sf->cls,
+             pid);
 }
 
 
@@ -583,10 +590,10 @@ GAS_plugin_request_connect_start(const struct GNUNET_PeerIdentity *pid)
  * @param pid identity of peer we care now less about
  */
 void
-GAS_plugin_request_connect_stop(const struct GNUNET_PeerIdentity *pid)
+GAS_plugin_request_connect_stop (const struct GNUNET_PeerIdentity *pid)
 {
-  sf->s_get_stop(sf->cls,
-                 pid);
+  sf->s_get_stop (sf->cls,
+                  pid);
 }
 
 
diff --git a/src/ats/gnunet-service-ats_plugins.h b/src/ats/gnunet-service-ats_plugins.h
index e2256f691..4165fe9e2 100644
--- a/src/ats/gnunet-service-ats_plugins.h
+++ b/src/ats/gnunet-service-ats_plugins.h
@@ -41,14 +41,14 @@
  *         solver plugin)
  */
 int
-GAS_plugin_init(const struct GNUNET_CONFIGURATION_Handle *cfg);
+GAS_plugin_init (const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 
 /**
  * Shutdown address subsystem.
  */
 void
-GAS_plugin_done(void);
+GAS_plugin_done (void);
 
 
 /**
@@ -59,9 +59,9 @@ GAS_plugin_done(void);
  * @param pref_rel the new relative preference value
  */
 void
-GAS_plugin_notify_preference_changed(const struct GNUNET_PeerIdentity *peer,
-                                     enum GNUNET_ATS_PreferenceKind kind,
-                                     double pref_rel);
+GAS_plugin_notify_preference_changed (const struct GNUNET_PeerIdentity *peer,
+                                      enum GNUNET_ATS_PreferenceKind kind,
+                                      double pref_rel);
 
 
 /**
@@ -70,7 +70,7 @@ GAS_plugin_notify_preference_changed(const struct GNUNET_PeerIdentity *peer,
  * @param address the peer
  */
 void
-GAS_plugin_notify_property_changed(struct ATS_Address *address);
+GAS_plugin_notify_property_changed (struct ATS_Address *address);
 
 
 /**
@@ -81,7 +81,7 @@ GAS_plugin_notify_property_changed(struct ATS_Address *address);
  * @param addr_net network scope the address is in
  */
 void
-GAS_plugin_new_address(struct ATS_Address *new_address);
+GAS_plugin_new_address (struct ATS_Address *new_address);
 
 
 /**
@@ -91,7 +91,7 @@ GAS_plugin_new_address(struct ATS_Address *new_address);
  * @param address address that was deleted
  */
 void
-GAS_plugin_delete_address(struct ATS_Address *address);
+GAS_plugin_delete_address (struct ATS_Address *address);
 
 
 /**
@@ -105,11 +105,11 @@ GAS_plugin_delete_address(struct ATS_Address *address);
  * @param score_abs degree of the appreciation
  */
 void
-GAS_plugin_notify_feedback(struct GNUNET_SERVICE_Client *application,
-                           const struct GNUNET_PeerIdentity *peer,
-                           const struct GNUNET_TIME_Relative scope,
-                           enum GNUNET_ATS_PreferenceKind kind,
-                           float score_abs);
+GAS_plugin_notify_feedback (struct GNUNET_SERVICE_Client *application,
+                            const struct GNUNET_PeerIdentity *peer,
+                            const struct GNUNET_TIME_Relative scope,
+                            enum GNUNET_ATS_PreferenceKind kind,
+                            float score_abs);
 
 
 /**
@@ -117,14 +117,14 @@ GAS_plugin_notify_feedback(struct GNUNET_SERVICE_Client *application,
  * happening in bulk right now.
  */
 void
-GAS_plugin_solver_lock(void);
+GAS_plugin_solver_lock (void);
 
 
 /**
  * Resume instant solving, we are done with the bulk state updates.
  */
 void
-GAS_plugin_solver_unlock(void);
+GAS_plugin_solver_unlock (void);
 
 
 /**
@@ -134,7 +134,7 @@ GAS_plugin_solver_unlock(void);
  * @param pid identity of peer we now care about
  */
 void
-GAS_plugin_request_connect_start(const struct GNUNET_PeerIdentity *pid);
+GAS_plugin_request_connect_start (const struct GNUNET_PeerIdentity *pid);
 
 
 /**
@@ -144,7 +144,7 @@ GAS_plugin_request_connect_start(const struct GNUNET_PeerIdentity *pid);
  * @param pid identity of peer we care now less about
  */
 void
-GAS_plugin_request_connect_stop(const struct GNUNET_PeerIdentity *pid);
+GAS_plugin_request_connect_stop (const struct GNUNET_PeerIdentity *pid);
 
 
 #endif
diff --git a/src/ats/gnunet-service-ats_preferences.c b/src/ats/gnunet-service-ats_preferences.c
index 0a12faaae..636e2db47 100644
--- a/src/ats/gnunet-service-ats_preferences.c
+++ b/src/ats/gnunet-service-ats_preferences.c
@@ -32,12 +32,13 @@
 #include "gnunet-service-ats_reservations.h"
 #include "ats.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-preferences", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-preferences", __VA_ARGS__)
 
 /**
  * How frequently do we age preference values?
  */
-#define PREF_AGING_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10)
+#define PREF_AGING_INTERVAL GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 10)
 
 /**
  * By which factor do we age preferences expressed during
@@ -56,7 +57,8 @@
 /**
  * Relative preferences for a peer.
  */
-struct PeerRelative {
+struct PeerRelative
+{
   /**
    * Array of relative preference values, to be indexed by
    * an `enum GNUNET_ATS_PreferenceKind`.
@@ -82,7 +84,8 @@ static struct PeerRelative defvalues;
 /**
  * Preference information per peer and client.
  */
-struct PreferencePeer {
+struct PreferencePeer
+{
   /**
    * Next in DLL of preference entries for the same client.
    */
@@ -113,7 +116,8 @@ struct PreferencePeer {
  * for peers.  This is the information we keep track of for each
  * such client.
  */
-struct PreferenceClient {
+struct PreferenceClient
+{
   /**
    * Next in client list
    */
@@ -169,7 +173,8 @@ static struct GNUNET_SCHEDULER_Task *aging_task;
 /**
  * Closure for #sum_relative_preferences().
  */
-struct SumContext {
+struct SumContext
+{
   /**
    * Where to accumulate the result.
    */
@@ -193,9 +198,9 @@ struct SumContext {
  * @return #GNUNET_OK
  */
 static int
-sum_relative_preferences(void *cls,
-                         const struct GNUNET_PeerIdentity *peer,
-                         void *value)
+sum_relative_preferences (void *cls,
+                          const struct GNUNET_PeerIdentity *peer,
+                          void *value)
 {
   struct SumContext *sum_ctx = cls;
   struct PreferencePeer *p_cur = value;
@@ -214,8 +219,8 @@ sum_relative_preferences(void *cls,
  * @return the new relative preference
  */
 static void
-update_relative_values_for_peer(const struct GNUNET_PeerIdentity *id,
-                                enum GNUNET_ATS_PreferenceKind kind)
+update_relative_values_for_peer (const struct GNUNET_PeerIdentity *id,
+                                 enum GNUNET_ATS_PreferenceKind kind)
 {
   struct PreferenceClient *c_cur;
   struct SumContext sum_ctx;
@@ -224,25 +229,25 @@ update_relative_values_for_peer(const struct GNUNET_PeerIdentity *id,
   sum_ctx.f_rel_total = 0.0;
   sum_ctx.kind = kind;
   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
-    GNUNET_CONTAINER_multipeermap_get_multiple(c_cur->peer2pref,
-                                               id,
-                                               &sum_relative_preferences,
-                                               &sum_ctx);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Total relative preference for peer `%s' for `%s' is %.3f\n",
-      GNUNET_i2s(id),
-      GNUNET_ATS_print_preference_type(kind),
-      sum_ctx.f_rel_total);
-  rp = GNUNET_CONTAINER_multipeermap_get(preference_peers,
-                                         id);
-  GNUNET_assert(NULL != rp);
+    GNUNET_CONTAINER_multipeermap_get_multiple (c_cur->peer2pref,
+                                                id,
+                                                &sum_relative_preferences,
+                                                &sum_ctx);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Total relative preference for peer `%s' for `%s' is %.3f\n",
+       GNUNET_i2s (id),
+       GNUNET_ATS_print_preference_type (kind),
+       sum_ctx.f_rel_total);
+  rp = GNUNET_CONTAINER_multipeermap_get (preference_peers,
+                                          id);
+  GNUNET_assert (NULL != rp);
   if (rp->f_rel[kind] != sum_ctx.f_rel_total)
-    {
-      rp->f_rel[kind] = sum_ctx.f_rel_total;
-      GAS_plugin_notify_preference_changed(id,
-                                           kind,
-                                           rp->f_rel[kind]);
-    }
+  {
+    rp->f_rel[kind] = sum_ctx.f_rel_total;
+    GAS_plugin_notify_preference_changed (id,
+                                          kind,
+                                          rp->f_rel[kind]);
+  }
 }
 
 
@@ -255,17 +260,17 @@ update_relative_values_for_peer(const struct GNUNET_PeerIdentity *id,
  * @return #GNUNET_OK to continue
  */
 static int
-free_peer(void *cls,
-          const struct GNUNET_PeerIdentity *key,
-          void *value)
+free_peer (void *cls,
+           const struct GNUNET_PeerIdentity *key,
+           void *value)
 {
   struct PeerRelative *rp = value;
 
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(preference_peers,
-                                                     key,
-                                                     value));
-  GNUNET_free(rp);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (preference_peers,
+                                                       key,
+                                                       value));
+  GNUNET_free (rp);
   return GNUNET_OK;
 }
 
@@ -279,30 +284,30 @@ free_peer(void *cls,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_preference(void *cls,
-                const struct GNUNET_PeerIdentity *key,
-                void *value)
+free_preference (void *cls,
+                 const struct GNUNET_PeerIdentity *key,
+                 void *value)
 {
   struct PreferenceClient *pc = cls;
   struct PreferencePeer *p = value;
   struct PeerRelative *pr;
 
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_remove(pc->peer2pref,
-                                                     key,
-                                                     p));
-  GNUNET_free(p);
-  pr = GNUNET_CONTAINER_multipeermap_get(preference_peers,
-                                         key);
-  GNUNET_assert(NULL != pr);
-  GNUNET_assert(pr->num_clients > 0);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_remove (pc->peer2pref,
+                                                       key,
+                                                       p));
+  GNUNET_free (p);
+  pr = GNUNET_CONTAINER_multipeermap_get (preference_peers,
+                                          key);
+  GNUNET_assert (NULL != pr);
+  GNUNET_assert (pr->num_clients > 0);
   pr->num_clients--;
   if (0 == pr->num_clients)
-    {
-      free_peer(NULL,
-                key,
-                pr);
-    }
+  {
+    free_peer (NULL,
+               key,
+               pr);
+  }
   return GNUNET_OK;
 }
 
@@ -310,7 +315,8 @@ free_preference(void *cls,
 /**
  * Closure for #age_values().
  */
-struct AgeContext {
+struct AgeContext
+{
   /**
    * Counter of values remaining to update, incremented for each value
    * changed (to a new non-zero value).
@@ -333,9 +339,9 @@ struct AgeContext {
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-age_values(void *cls,
-           const struct GNUNET_PeerIdentity *peer,
-           void *value)
+age_values (void *cls,
+            const struct GNUNET_PeerIdentity *peer,
+            void *value)
 {
   struct AgeContext *ac = cls;
   struct PreferencePeer *p = value;
@@ -344,32 +350,32 @@ age_values(void *cls,
 
   dead = GNUNET_YES;
   for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Aging preference for peer `%s'\n",
+                GNUNET_i2s (peer));
+    if (p->f_abs[i] > DEFAULT_ABS_PREFERENCE)
+      p->f_abs[i] *= PREF_AGING_FACTOR;
+    if (p->f_abs[i] <= DEFAULT_ABS_PREFERENCE + PREF_EPSILON)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Aging preference for peer `%s'\n",
-                 GNUNET_i2s(peer));
-      if (p->f_abs[i] > DEFAULT_ABS_PREFERENCE)
-        p->f_abs[i] *= PREF_AGING_FACTOR;
-      if (p->f_abs[i] <= DEFAULT_ABS_PREFERENCE + PREF_EPSILON)
-        {
-          p->f_abs[i] = DEFAULT_ABS_PREFERENCE;
-          p->f_rel[i] = DEFAULT_REL_PREFERENCE;
-          update_relative_values_for_peer(peer,
-                                          i);
-        }
-      else
-        {
-          ac->values_to_update++;
-          dead = GNUNET_NO;
-        }
+      p->f_abs[i] = DEFAULT_ABS_PREFERENCE;
+      p->f_rel[i] = DEFAULT_REL_PREFERENCE;
+      update_relative_values_for_peer (peer,
+                                       i);
     }
-  if (GNUNET_YES == dead)
+    else
     {
-      /* all preferences are zero, remove this entry */
-      free_preference(ac->cur_client,
-                      peer,
-                      p);
+      ac->values_to_update++;
+      dead = GNUNET_NO;
     }
+  }
+  if (GNUNET_YES == dead)
+  {
+    /* all preferences are zero, remove this entry */
+    free_preference (ac->cur_client,
+                     peer,
+                     p);
+  }
   return GNUNET_OK;
 }
 
@@ -380,40 +386,42 @@ age_values(void *cls,
  * @param cls unused
  */
 static void
-preference_aging(void *cls)
+preference_aging (void *cls)
 {
   struct AgeContext ac;
 
   aging_task = NULL;
-  GAS_plugin_solver_lock();
+  GAS_plugin_solver_lock ();
   ac.values_to_update = 0;
-  for (ac.cur_client = pc_head; NULL != ac.cur_client; ac.cur_client = ac.cur_client->next)
-    GNUNET_CONTAINER_multipeermap_iterate(ac.cur_client->peer2pref,
-                                          &age_values,
-                                          &ac);
-  GAS_plugin_solver_unlock();
+  for (ac.cur_client = pc_head; NULL != ac.cur_client; ac.cur_client =
+         ac.cur_client->next)
+    GNUNET_CONTAINER_multipeermap_iterate (ac.cur_client->peer2pref,
+                                           &age_values,
+                                           &ac);
+  GAS_plugin_solver_unlock ();
   if (ac.values_to_update > 0)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Rescheduling aging task due to %u elements remaining to age\n",
-                 ac.values_to_update);
-      if (NULL == aging_task)
-        aging_task = GNUNET_SCHEDULER_add_delayed(PREF_AGING_INTERVAL,
-                                                  &preference_aging,
-                                                  NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Rescheduling aging task due to %u elements remaining to age\n",
+                ac.values_to_update);
+    if (NULL == aging_task)
+      aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
+                                                 &preference_aging,
+                                                 NULL);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "No values to age left, not rescheduling aging task\n");
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No values to age left, not rescheduling aging task\n");
+  }
 }
 
 
 /**
  * Closure for #update_rel_sum() and #update_abs_sum().
  */
-struct UpdateContext {
+struct UpdateContext
+{
   /**
    * Preference client with the sum of all absolute scores.
    */
@@ -436,9 +444,9 @@ struct UpdateContext {
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-update_abs_sum(void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               void *value)
+update_abs_sum (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                void *value)
 {
   struct UpdateContext *uc = cls;
   struct PreferencePeer *p_cur = value;
@@ -458,19 +466,19 @@ update_abs_sum(void *cls,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-update_rel_sum(void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               void *value)
+update_rel_sum (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                void *value)
 {
   struct UpdateContext *uc = cls;
   struct PreferencePeer *p_cur = value;
 
   p_cur->f_rel[uc->kind] = p_cur->f_abs[uc->kind] / uc->pc->f_abs_sum[uc->kind];
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Client has relative preference for %s for peer `%s' of %.3f\n",
-      GNUNET_ATS_print_preference_type(uc->kind),
-      GNUNET_i2s(peer),
-      p_cur->f_rel[uc->kind]);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client has relative preference for %s for peer `%s' of %.3f\n",
+       GNUNET_ATS_print_preference_type (uc->kind),
+       GNUNET_i2s (peer),
+       p_cur->f_rel[uc->kind]);
   return GNUNET_OK;
 }
 
@@ -483,8 +491,8 @@ update_rel_sum(void *cls,
  * @return the result
  */
 static void
-recalculate_relative_preferences(struct PreferenceClient *c,
-                                 enum GNUNET_ATS_PreferenceKind kind)
+recalculate_relative_preferences (struct PreferenceClient *c,
+                                  enum GNUNET_ATS_PreferenceKind kind)
 {
   struct UpdateContext uc;
 
@@ -494,18 +502,18 @@ recalculate_relative_preferences(struct PreferenceClient *c,
   c->f_abs_sum[kind] = 0.0;
 
   /* For all peers: calculate sum of absolute preferences */
-  GNUNET_CONTAINER_multipeermap_iterate(c->peer2pref,
-                                        &update_abs_sum,
-                                        &uc);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Client has sum of total preferences for %s of %.3f\n",
-      GNUNET_ATS_print_preference_type(kind),
-      c->f_abs_sum[kind]);
+  GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
+                                         &update_abs_sum,
+                                         &uc);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client has sum of total preferences for %s of %.3f\n",
+       GNUNET_ATS_print_preference_type (kind),
+       c->f_abs_sum[kind]);
 
   /* For all peers: calculate relative preference */
-  GNUNET_CONTAINER_multipeermap_iterate(c->peer2pref,
-                                        &update_rel_sum,
-                                        &uc);
+  GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
+                                         &update_rel_sum,
+                                         &uc);
 }
 
 
@@ -520,14 +528,14 @@ recalculate_relative_preferences(struct PreferenceClient *c,
  * @param value a `struct PeerRelative`, unused
  */
 static int
-update_iterator(void *cls,
-                const struct GNUNET_PeerIdentity *key,
-                void *value)
+update_iterator (void *cls,
+                 const struct GNUNET_PeerIdentity *key,
+                 void *value)
 {
   enum GNUNET_ATS_PreferenceKind *kind = cls;
 
-  update_relative_values_for_peer(key,
-                                  *kind);
+  update_relative_values_for_peer (key,
+                                   *kind);
   return GNUNET_OK;
 }
 
@@ -542,10 +550,10 @@ update_iterator(void *cls,
  * @param score_abs the normalized score
  */
 static void
-update_preference(struct GNUNET_SERVICE_Client *client,
-                  const struct GNUNET_PeerIdentity *peer,
-                  enum GNUNET_ATS_PreferenceKind kind,
-                  float score_abs)
+update_preference (struct GNUNET_SERVICE_Client *client,
+                   const struct GNUNET_PeerIdentity *peer,
+                   enum GNUNET_ATS_PreferenceKind kind,
+                   float score_abs)
 {
   struct PreferenceClient *c_cur;
   struct PreferencePeer *p_cur;
@@ -553,15 +561,15 @@ update_preference(struct GNUNET_SERVICE_Client *client,
   unsigned int i;
 
   if (kind >= GNUNET_ATS_PREFERENCE_END)
-    {
-      GNUNET_break(0);
-      return;
-    }
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Client changes preference for peer `%s' for `%s' to %.2f\n",
-      GNUNET_i2s(peer),
-      GNUNET_ATS_print_preference_type(kind),
-      score_abs);
+  {
+    GNUNET_break (0);
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client changes preference for peer `%s' for `%s' to %.2f\n",
+       GNUNET_i2s (peer),
+       GNUNET_ATS_print_preference_type (kind),
+       score_abs);
 
   /* Find preference client */
   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
@@ -569,66 +577,66 @@ update_preference(struct GNUNET_SERVICE_Client *client,
       break;
   /* Not found: create new preference client */
   if (NULL == c_cur)
-    {
-      c_cur = GNUNET_new(struct PreferenceClient);
-      c_cur->client = client;
-      c_cur->peer2pref = GNUNET_CONTAINER_multipeermap_create(16,
-                                                              GNUNET_NO);
-      for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
-        c_cur->f_abs_sum[i] = DEFAULT_ABS_PREFERENCE;
-      GNUNET_CONTAINER_DLL_insert(pc_head,
-                                  pc_tail,
-                                  c_cur);
-    }
+  {
+    c_cur = GNUNET_new (struct PreferenceClient);
+    c_cur->client = client;
+    c_cur->peer2pref = GNUNET_CONTAINER_multipeermap_create (16,
+                                                             GNUNET_NO);
+    for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
+      c_cur->f_abs_sum[i] = DEFAULT_ABS_PREFERENCE;
+    GNUNET_CONTAINER_DLL_insert (pc_head,
+                                 pc_tail,
+                                 c_cur);
+  }
 
   /* check global peer entry exists */
   if (NULL ==
-      (r_cur = GNUNET_CONTAINER_multipeermap_get(preference_peers,
-                                                 peer)))
-    {
-      /* Create struct for peer */
-      r_cur = GNUNET_new(struct PeerRelative);
-      for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
-        r_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONTAINER_multipeermap_put(preference_peers,
+      (r_cur = GNUNET_CONTAINER_multipeermap_get (preference_peers,
+                                                  peer)))
+  {
+    /* Create struct for peer */
+    r_cur = GNUNET_new (struct PeerRelative);
+    for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
+      r_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_put (preference_peers,
                                                       peer,
                                                       r_cur,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
+  }
 
   /* Find entry for peer */
-  p_cur = GNUNET_CONTAINER_multipeermap_get(c_cur->peer2pref,
-                                            peer);
+  p_cur = GNUNET_CONTAINER_multipeermap_get (c_cur->peer2pref,
+                                             peer);
   if (NULL == p_cur)
+  {
+    /* Not found: create new peer entry */
+    p_cur = GNUNET_new (struct PreferencePeer);
+    for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
     {
-      /* Not found: create new peer entry */
-      p_cur = GNUNET_new(struct PreferencePeer);
-      for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
-        {
-          /* Default value per peer absolute preference for a preference*/
-          p_cur->f_abs[i] = DEFAULT_ABS_PREFERENCE;
-          /* Default value per peer relative preference for a quality */
-          p_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
-        }
-      GNUNET_assert(GNUNET_YES ==
-                    GNUNET_CONTAINER_multipeermap_put(c_cur->peer2pref,
+      /* Default value per peer absolute preference for a preference*/
+      p_cur->f_abs[i] = DEFAULT_ABS_PREFERENCE;
+      /* Default value per peer relative preference for a quality */
+      p_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
+    }
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_put (c_cur->peer2pref,
                                                       peer,
                                                       p_cur,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      r_cur->num_clients++;
-    }
+    r_cur->num_clients++;
+  }
 
   p_cur->f_abs[kind] += score_abs;
-  recalculate_relative_preferences(c_cur, kind);
-  GNUNET_CONTAINER_multipeermap_iterate(preference_peers,
-                                        &update_iterator,
-                                        &kind);
+  recalculate_relative_preferences (c_cur, kind);
+  GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
+                                         &update_iterator,
+                                         &kind);
 
   if (NULL == aging_task)
-    aging_task = GNUNET_SCHEDULER_add_delayed(PREF_AGING_INTERVAL,
-                                              &preference_aging,
-                                              NULL);
+    aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
+                                               &preference_aging,
+                                               NULL);
 }
 
 
@@ -639,28 +647,29 @@ update_preference(struct GNUNET_SERVICE_Client *client,
  * @param msg the request message
  */
 void
-GAS_handle_preference_change(struct GNUNET_SERVICE_Client *client,
-                             const struct ChangePreferenceMessage *msg)
+GAS_handle_preference_change (struct GNUNET_SERVICE_Client *client,
+                              const struct ChangePreferenceMessage *msg)
 {
   const struct PreferenceInformation *pi;
   uint32_t nump;
 
-  nump = ntohl(msg->num_preferences);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received PREFERENCE_CHANGE message for peer `%s'\n",
-             GNUNET_i2s(&msg->peer));
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# preference change requests processed",
-                           1,
-                           GNUNET_NO);
-  pi = (const struct PreferenceInformation *)&msg[1];
-  GAS_plugin_solver_lock();
+  nump = ntohl (msg->num_preferences);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received PREFERENCE_CHANGE message for peer `%s'\n",
+              GNUNET_i2s (&msg->peer));
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# preference change requests processed",
+                            1,
+                            GNUNET_NO);
+  pi = (const struct PreferenceInformation *) &msg[1];
+  GAS_plugin_solver_lock ();
   for (uint32_t i = 0; i < nump; i++)
-    update_preference(client,
-                      &msg->peer,
-                      (enum GNUNET_ATS_PreferenceKind)ntohl(pi[i].preference_kind),
-                      pi[i].preference_value);
-  GAS_plugin_solver_unlock();
+    update_preference (client,
+                       &msg->peer,
+                       (enum GNUNET_ATS_PreferenceKind) ntohl (
+                         pi[i].preference_kind),
+                       pi[i].preference_value);
+  GAS_plugin_solver_unlock ();
 }
 
 
@@ -668,12 +677,12 @@ GAS_handle_preference_change(struct GNUNET_SERVICE_Client *client,
  * Initialize preferences subsystem.
  */
 void
-GAS_preference_init()
+GAS_preference_init ()
 {
   unsigned int i;
 
-  preference_peers = GNUNET_CONTAINER_multipeermap_create(16,
-                                                          GNUNET_NO);
+  preference_peers = GNUNET_CONTAINER_multipeermap_create (16,
+                                                           GNUNET_NO);
   for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
     defvalues.f_rel[i] = DEFAULT_REL_PREFERENCE;
 }
@@ -683,33 +692,33 @@ GAS_preference_init()
  * Shutdown preferences subsystem.
  */
 void
-GAS_preference_done()
+GAS_preference_done ()
 {
   struct PreferenceClient *pc;
   struct PreferenceClient *next_pc;
 
   if (NULL != aging_task)
-    {
-      GNUNET_SCHEDULER_cancel(aging_task);
-      aging_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (aging_task);
+    aging_task = NULL;
+  }
   next_pc = pc_head;
   while (NULL != (pc = next_pc))
-    {
-      next_pc = pc->next;
-      GNUNET_CONTAINER_DLL_remove(pc_head,
-                                  pc_tail,
-                                  pc);
-      GNUNET_CONTAINER_multipeermap_iterate(pc->peer2pref,
-                                            &free_preference,
-                                            pc);
-      GNUNET_CONTAINER_multipeermap_destroy(pc->peer2pref);
-      GNUNET_free(pc);
-    }
-  GNUNET_CONTAINER_multipeermap_iterate(preference_peers,
-                                        &free_peer,
-                                        NULL);
-  GNUNET_CONTAINER_multipeermap_destroy(preference_peers);
+  {
+    next_pc = pc->next;
+    GNUNET_CONTAINER_DLL_remove (pc_head,
+                                 pc_tail,
+                                 pc);
+    GNUNET_CONTAINER_multipeermap_iterate (pc->peer2pref,
+                                           &free_preference,
+                                           pc);
+    GNUNET_CONTAINER_multipeermap_destroy (pc->peer2pref);
+    GNUNET_free (pc);
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
+                                         &free_peer,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (preference_peers);
 }
 
 
@@ -723,17 +732,17 @@ GAS_preference_done()
  * default preferences if peer does not exist
  */
 const double *
-GAS_preference_get_by_peer(void *cls,
-                           const struct GNUNET_PeerIdentity *id)
+GAS_preference_get_by_peer (void *cls,
+                            const struct GNUNET_PeerIdentity *id)
 {
   struct PeerRelative *rp;
 
   if (NULL ==
-      (rp = GNUNET_CONTAINER_multipeermap_get(preference_peers,
-                                              id)))
-    {
-      return defvalues.f_rel;
-    }
+      (rp = GNUNET_CONTAINER_multipeermap_get (preference_peers,
+                                               id)))
+  {
+    return defvalues.f_rel;
+  }
   return rp->f_rel;
 }
 
@@ -744,7 +753,7 @@ GAS_preference_get_by_peer(void *cls,
  * @param client the client
  */
 void
-GAS_preference_client_disconnect(struct GNUNET_SERVICE_Client *client)
+GAS_preference_client_disconnect (struct GNUNET_SERVICE_Client *client)
 {
   struct PreferenceClient *c_cur;
 
@@ -753,14 +762,14 @@ GAS_preference_client_disconnect(struct GNUNET_SERVICE_Client *client)
       break;
   if (NULL == c_cur)
     return;
-  GNUNET_CONTAINER_DLL_remove(pc_head,
-                              pc_tail,
-                              c_cur);
-  GNUNET_CONTAINER_multipeermap_iterate(c_cur->peer2pref,
-                                        &free_preference,
-                                        c_cur);
-  GNUNET_CONTAINER_multipeermap_destroy(c_cur->peer2pref);
-  GNUNET_free(c_cur);
+  GNUNET_CONTAINER_DLL_remove (pc_head,
+                               pc_tail,
+                               c_cur);
+  GNUNET_CONTAINER_multipeermap_iterate (c_cur->peer2pref,
+                                         &free_preference,
+                                         c_cur);
+  GNUNET_CONTAINER_multipeermap_destroy (c_cur->peer2pref);
+  GNUNET_free (c_cur);
 }
 
 
diff --git a/src/ats/gnunet-service-ats_preferences.h b/src/ats/gnunet-service-ats_preferences.h
index 48aa33ea6..49bf2ddbd 100644
--- a/src/ats/gnunet-service-ats_preferences.h
+++ b/src/ats/gnunet-service-ats_preferences.h
@@ -50,22 +50,22 @@
  * @param msg the request message
  */
 void
-GAS_handle_preference_change(struct GNUNET_SERVICE_Client *client,
-                             const struct ChangePreferenceMessage *msg);
+GAS_handle_preference_change (struct GNUNET_SERVICE_Client *client,
+                              const struct ChangePreferenceMessage *msg);
 
 
 /**
  * Initialize preferences subsystem.
  */
 void
-GAS_preference_init(void);
+GAS_preference_init (void);
 
 
 /**
  * Shutdown preferences subsystem.
  */
 void
-GAS_preference_done(void);
+GAS_preference_done (void);
 
 
 /**
@@ -77,8 +77,8 @@ GAS_preference_done(void);
  *  with `enum GNUNET_ATS_PreferenceKind`, never NULL
  */
 const double *
-GAS_preference_get_by_peer(void *cls,
-                           const struct GNUNET_PeerIdentity *id);
+GAS_preference_get_by_peer (void *cls,
+                            const struct GNUNET_PeerIdentity *id);
 
 
 /**
@@ -87,7 +87,7 @@ GAS_preference_get_by_peer(void *cls,
  * @param client the disconnecting client
  */
 void
-GAS_preference_client_disconnect(struct GNUNET_SERVICE_Client *client);
+GAS_preference_client_disconnect (struct GNUNET_SERVICE_Client *client);
 
 
 #endif
diff --git a/src/ats/gnunet-service-ats_reservations.c b/src/ats/gnunet-service-ats_reservations.c
index ec1f4b0d5..c4367fb85 100644
--- a/src/ats/gnunet-service-ats_reservations.c
+++ b/src/ats/gnunet-service-ats_reservations.c
@@ -53,38 +53,38 @@ static struct GNUNET_CONTAINER_MultiPeerMap *trackers;
  *         until the reservation might succeed
  */
 static struct GNUNET_TIME_Relative
-reservations_reserve(const struct GNUNET_PeerIdentity *peer,
-                     int32_t amount)
+reservations_reserve (const struct GNUNET_PeerIdentity *peer,
+                      int32_t amount)
 {
   struct GNUNET_BANDWIDTH_Tracker *tracker;
   struct GNUNET_TIME_Relative ret;
 
-  tracker = GNUNET_CONTAINER_multipeermap_get(trackers,
-                                              peer);
+  tracker = GNUNET_CONTAINER_multipeermap_get (trackers,
+                                               peer);
   if (NULL == tracker)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Not connected, allowing reservation of %d bytes\n",
-                 (int)amount);
-      return GNUNET_TIME_UNIT_ZERO;     /* not connected, satisfy now */
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not connected, allowing reservation of %d bytes\n",
+                (int) amount);
+    return GNUNET_TIME_UNIT_ZERO;       /* not connected, satisfy now */
+  }
   if (amount >= 0)
+  {
+    ret = GNUNET_BANDWIDTH_tracker_get_delay (tracker, amount);
+    if (ret.rel_value_us > 0)
     {
-      ret = GNUNET_BANDWIDTH_tracker_get_delay(tracker, amount);
-      if (ret.rel_value_us > 0)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Delay to satisfy reservation for %d bytes is %s\n",
-                     (int)amount,
-                     GNUNET_STRINGS_relative_time_to_string(ret,
-                                                            GNUNET_YES));
-          return ret;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Delay to satisfy reservation for %d bytes is %s\n",
+                  (int) amount,
+                  GNUNET_STRINGS_relative_time_to_string (ret,
+                                                          GNUNET_YES));
+      return ret;
     }
-  (void)GNUNET_BANDWIDTH_tracker_consume(tracker, amount);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Reserved %d bytes\n",
-             (int)amount);
+  }
+  (void) GNUNET_BANDWIDTH_tracker_consume (tracker, amount);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Reserved %d bytes\n",
+              (int) amount);
   return GNUNET_TIME_UNIT_ZERO;
 }
 
@@ -98,40 +98,40 @@ reservations_reserve(const struct GNUNET_PeerIdentity *peer,
  *        this peer (estimate)
  */
 void
-GAS_reservations_set_bandwidth(const struct GNUNET_PeerIdentity *peer,
-                               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+GAS_reservations_set_bandwidth (const struct GNUNET_PeerIdentity *peer,
+                                struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
   struct GNUNET_BANDWIDTH_Tracker *tracker;
 
-  tracker = GNUNET_CONTAINER_multipeermap_get(trackers, peer);
-  if (0 == ntohl(bandwidth_in.value__))
-    {
-      if (NULL == tracker)
-        return;
-      GNUNET_assert(GNUNET_YES ==
-                    GNUNET_CONTAINER_multipeermap_remove(trackers,
+  tracker = GNUNET_CONTAINER_multipeermap_get (trackers, peer);
+  if (0 == ntohl (bandwidth_in.value__))
+  {
+    if (NULL == tracker)
+      return;
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_remove (trackers,
                                                          peer,
                                                          tracker));
-      GNUNET_free(tracker);
-      return;
-    }
+    GNUNET_free (tracker);
+    return;
+  }
   if (NULL == tracker)
-    {
-      tracker = GNUNET_new(struct GNUNET_BANDWIDTH_Tracker);
-      GNUNET_BANDWIDTH_tracker_init(tracker,
-                                    NULL,
-                                    NULL,
-                                    bandwidth_in,
-                                    MAX_BANDWIDTH_CARRY_S);
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONTAINER_multipeermap_put(trackers,
+  {
+    tracker = GNUNET_new (struct GNUNET_BANDWIDTH_Tracker);
+    GNUNET_BANDWIDTH_tracker_init (tracker,
+                                   NULL,
+                                   NULL,
+                                   bandwidth_in,
+                                   MAX_BANDWIDTH_CARRY_S);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_put (trackers,
                                                       peer,
                                                       tracker,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      return;
-    }
-  GNUNET_BANDWIDTH_tracker_update_quota(tracker,
-                                        bandwidth_in);
+    return;
+  }
+  GNUNET_BANDWIDTH_tracker_update_quota (tracker,
+                                         bandwidth_in);
 }
 
 
@@ -142,31 +142,31 @@ GAS_reservations_set_bandwidth(const struct GNUNET_PeerIdentity *peer,
  * @param msg the request message
  */
 void
-GAS_handle_reservation_request(struct GNUNET_SERVICE_Client *client,
-                               const struct ReservationRequestMessage *msg)
+GAS_handle_reservation_request (struct GNUNET_SERVICE_Client *client,
+                                const struct ReservationRequestMessage *msg)
 {
   struct GNUNET_MQ_Envelope *env;
   struct ReservationResultMessage *result;
   int32_t amount;
   struct GNUNET_TIME_Relative res_delay;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received RESERVATION_REQUEST message\n");
-  amount = (int32_t)ntohl(msg->amount);
-  res_delay = reservations_reserve(&msg->peer, amount);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received RESERVATION_REQUEST message\n");
+  amount = (int32_t) ntohl (msg->amount);
+  res_delay = reservations_reserve (&msg->peer, amount);
   if (res_delay.rel_value_us > 0)
     amount = 0;
-  env = GNUNET_MQ_msg(result,
-                      GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT);
-  result->amount = htonl(amount);
+  env = GNUNET_MQ_msg (result,
+                       GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT);
+  result->amount = htonl (amount);
   result->peer = msg->peer;
-  result->res_delay = GNUNET_TIME_relative_hton(res_delay);
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# reservation requests processed",
-                           1,
-                           GNUNET_NO);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client),
-                 env);
+  result->res_delay = GNUNET_TIME_relative_hton (res_delay);
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# reservation requests processed",
+                            1,
+                            GNUNET_NO);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
 }
 
 
@@ -174,10 +174,10 @@ GAS_handle_reservation_request(struct GNUNET_SERVICE_Client *client,
  * Initialize reservations subsystem.
  */
 void
-GAS_reservations_init()
+GAS_reservations_init ()
 {
-  trackers = GNUNET_CONTAINER_multipeermap_create(128,
-                                                  GNUNET_NO);
+  trackers = GNUNET_CONTAINER_multipeermap_create (128,
+                                                   GNUNET_NO);
 }
 
 
@@ -190,13 +190,13 @@ GAS_reservations_init()
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_tracker(void *cls,
-             const struct GNUNET_PeerIdentity *key,
-             void *value)
+free_tracker (void *cls,
+              const struct GNUNET_PeerIdentity *key,
+              void *value)
 {
   struct GNUNET_BANDWIDTH_Tracker *tracker = value;
 
-  GNUNET_free(tracker);
+  GNUNET_free (tracker);
   return GNUNET_OK;
 }
 
@@ -205,12 +205,12 @@ free_tracker(void *cls,
  * Shutdown reservations subsystem.
  */
 void
-GAS_reservations_done()
+GAS_reservations_done ()
 {
-  GNUNET_CONTAINER_multipeermap_iterate(trackers,
-                                        &free_tracker,
-                                        NULL);
-  GNUNET_CONTAINER_multipeermap_destroy(trackers);
+  GNUNET_CONTAINER_multipeermap_iterate (trackers,
+                                         &free_tracker,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (trackers);
 }
 
 /* end of gnunet-service-ats_reservations.c */
diff --git a/src/ats/gnunet-service-ats_reservations.h b/src/ats/gnunet-service-ats_reservations.h
index 100cd9a90..d95945697 100644
--- a/src/ats/gnunet-service-ats_reservations.h
+++ b/src/ats/gnunet-service-ats_reservations.h
@@ -39,9 +39,9 @@
  *        this peer (estimate)
  */
 void
-GAS_reservations_set_bandwidth(const struct GNUNET_PeerIdentity *peer,
-                               struct GNUNET_BANDWIDTH_Value32NBO
-                               bandwidth_in);
+GAS_reservations_set_bandwidth (const struct GNUNET_PeerIdentity *peer,
+                                struct GNUNET_BANDWIDTH_Value32NBO
+                                bandwidth_in);
 
 
 /**
@@ -51,8 +51,9 @@ GAS_reservations_set_bandwidth(const struct GNUNET_PeerIdentity *peer,
  * @param message the request message
  */
 void
-GAS_handle_reservation_request(struct GNUNET_SERVICE_Client *client,
-                               const struct ReservationRequestMessage *message);
+GAS_handle_reservation_request (struct GNUNET_SERVICE_Client *client,
+                                const struct
+                                ReservationRequestMessage *message);
 
 
 /**
@@ -61,13 +62,13 @@ GAS_handle_reservation_request(struct GNUNET_SERVICE_Client *client,
  * @param server handle to our server
  */
 void
-GAS_reservations_init(void);
+GAS_reservations_init (void);
 
 
 /**
  * Shutdown reservations subsystem.
  */
 void
-GAS_reservations_done(void);
+GAS_reservations_done (void);
 
 #endif
diff --git a/src/ats/gnunet-service-ats_scheduling.c b/src/ats/gnunet-service-ats_scheduling.c
index d50df9b2e..456c222a9 100644
--- a/src/ats/gnunet-service-ats_scheduling.c
+++ b/src/ats/gnunet-service-ats_scheduling.c
@@ -42,14 +42,14 @@ static struct GNUNET_SERVICE_Client *my_client;
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GAS_scheduling_add_client(struct GNUNET_SERVICE_Client *client)
+GAS_scheduling_add_client (struct GNUNET_SERVICE_Client *client)
 {
   if (NULL != my_client)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "This ATS already has a scheduling client, refusing new scheduling client for now.\n");
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "This ATS already has a scheduling client, refusing new scheduling client for now.\n");
+    return GNUNET_SYSERR;
+  }
   my_client = client;
   return GNUNET_OK;
 }
@@ -62,11 +62,11 @@ GAS_scheduling_add_client(struct GNUNET_SERVICE_Client *client)
  * @param client handle of the (now dead) client
  */
 void
-GAS_scheduling_remove_client(struct GNUNET_SERVICE_Client *client)
+GAS_scheduling_remove_client (struct GNUNET_SERVICE_Client *client)
 {
   if (my_client != client)
     return;
-  GAS_addresses_destroy_all();
+  GAS_addresses_destroy_all ();
   my_client = NULL;
 }
 
@@ -81,33 +81,36 @@ GAS_scheduling_remove_client(struct GNUNET_SERVICE_Client *client)
  * @param bandwidth_in assigned inbound bandwidth
  */
 void
-GAS_scheduling_transmit_address_suggestion(const struct GNUNET_PeerIdentity *peer,
-                                           uint32_t session_id,
-                                           struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                                           struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+GAS_scheduling_transmit_address_suggestion (const struct
+                                            GNUNET_PeerIdentity *peer,
+                                            uint32_t session_id,
+                                            struct GNUNET_BANDWIDTH_Value32NBO
+                                            bandwidth_out,
+                                            struct GNUNET_BANDWIDTH_Value32NBO
+                                            bandwidth_in)
 {
   struct GNUNET_MQ_Envelope *env;
   struct AddressSuggestionMessage *msg;
 
   if (NULL == my_client)
     return;
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# address suggestions made",
-                           1,
-                           GNUNET_NO);
-  env = GNUNET_MQ_msg(msg,
-                      GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION);
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# address suggestions made",
+                            1,
+                            GNUNET_NO);
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION);
   msg->peer = *peer;
-  msg->session_id = htonl(session_id);
+  msg->session_id = htonl (session_id);
   msg->bandwidth_out = bandwidth_out;
   msg->bandwidth_in = bandwidth_in;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "ATS sends quota for peer `%s': (in/out) %u/%u\n",
-             GNUNET_i2s(peer),
-             (unsigned int)ntohl(bandwidth_in.value__),
-             (unsigned int)ntohl(bandwidth_out.value__));
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(my_client),
-                 env);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ATS sends quota for peer `%s': (in/out) %u/%u\n",
+              GNUNET_i2s (peer),
+              (unsigned int) ntohl (bandwidth_in.value__),
+              (unsigned int) ntohl (bandwidth_out.value__));
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (my_client),
+                  env);
 }
 
 
@@ -117,7 +120,7 @@ GAS_scheduling_transmit_address_suggestion(const struct GNUNET_PeerIdentity *pee
  * @param m the request message
  */
 void
-GAS_handle_address_add(const struct AddressAddMessage *m)
+GAS_handle_address_add (const struct AddressAddMessage *m)
 {
   const char *address;
   const char *plugin_name;
@@ -125,30 +128,30 @@ GAS_handle_address_add(const struct AddressAddMessage *m)
   uint16_t plugin_name_length;
   struct GNUNET_ATS_Properties prop;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received `%s' message\n",
-             "ADDRESS_ADD");
-  address_length = ntohs(m->address_length);
-  plugin_name_length = ntohs(m->plugin_name_length);
-  address = (const char *)&m[1];
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received `%s' message\n",
+              "ADDRESS_ADD");
+  address_length = ntohs (m->address_length);
+  plugin_name_length = ntohs (m->plugin_name_length);
+  address = (const char *) &m[1];
   if (plugin_name_length != 0)
     plugin_name = &address[address_length];
   else
     plugin_name = "";
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# addresses created",
-                           1,
-                           GNUNET_NO);
-  GNUNET_ATS_properties_ntoh(&prop,
-                             &m->properties);
-  GNUNET_break(GNUNET_NT_UNSPECIFIED != prop.scope);
-  GAS_addresses_add(&m->peer,
-                    plugin_name,
-                    address,
-                    address_length,
-                    ntohl(m->address_local_info),
-                    ntohl(m->session_id),
-                    &prop);
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# addresses created",
+                            1,
+                            GNUNET_NO);
+  GNUNET_ATS_properties_ntoh (&prop,
+                              &m->properties);
+  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop.scope);
+  GAS_addresses_add (&m->peer,
+                     plugin_name,
+                     address,
+                     address_length,
+                     ntohl (m->address_local_info),
+                     ntohl (m->session_id),
+                     &prop);
 }
 
 
@@ -158,19 +161,19 @@ GAS_handle_address_add(const struct AddressAddMessage *m)
  * @param m the request message
  */
 void
-GAS_handle_address_update(const struct AddressUpdateMessage *m)
+GAS_handle_address_update (const struct AddressUpdateMessage *m)
 {
   struct GNUNET_ATS_Properties prop;
 
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# address updates received",
-                           1,
-                           GNUNET_NO);
-  GNUNET_ATS_properties_ntoh(&prop,
-                             &m->properties);
-  GAS_addresses_update(&m->peer,
-                       ntohl(m->session_id),
-                       &prop);
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# address updates received",
+                            1,
+                            GNUNET_NO);
+  GNUNET_ATS_properties_ntoh (&prop,
+                              &m->properties);
+  GAS_addresses_update (&m->peer,
+                        ntohl (m->session_id),
+                        &prop);
 }
 
 
@@ -180,26 +183,26 @@ GAS_handle_address_update(const struct AddressUpdateMessage *m)
  * @param m the request message
  */
 void
-GAS_handle_address_destroyed(const struct AddressDestroyedMessage *m)
+GAS_handle_address_destroyed (const struct AddressDestroyedMessage *m)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_ATS_SessionReleaseMessage *srm;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received `%s' message\n",
-             "ADDRESS_DESTROYED");
-  GNUNET_STATISTICS_update(GSA_stats,
-                           "# addresses destroyed",
-                           1,
-                           GNUNET_NO);
-  GAS_addresses_destroy(&m->peer,
-                        ntohl(m->session_id));
-  env = GNUNET_MQ_msg(srm,
-                      GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received `%s' message\n",
+              "ADDRESS_DESTROYED");
+  GNUNET_STATISTICS_update (GSA_stats,
+                            "# addresses destroyed",
+                            1,
+                            GNUNET_NO);
+  GAS_addresses_destroy (&m->peer,
+                         ntohl (m->session_id));
+  env = GNUNET_MQ_msg (srm,
+                       GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE);
   srm->session_id = m->session_id;
   srm->peer = m->peer;
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(my_client),
-                 env);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (my_client),
+                  env);
 }
 
 
diff --git a/src/ats/gnunet-service-ats_scheduling.h b/src/ats/gnunet-service-ats_scheduling.h
index b2575ca60..d68306988 100644
--- a/src/ats/gnunet-service-ats_scheduling.h
+++ b/src/ats/gnunet-service-ats_scheduling.h
@@ -37,7 +37,7 @@
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GAS_scheduling_add_client(struct GNUNET_SERVICE_Client *client);
+GAS_scheduling_add_client (struct GNUNET_SERVICE_Client *client);
 
 
 /**
@@ -47,7 +47,7 @@ GAS_scheduling_add_client(struct GNUNET_SERVICE_Client *client);
  * @param client handle of the (now dead) client
  */
 void
-GAS_scheduling_remove_client(struct GNUNET_SERVICE_Client *client);
+GAS_scheduling_remove_client (struct GNUNET_SERVICE_Client *client);
 
 
 /**
@@ -60,10 +60,13 @@ GAS_scheduling_remove_client(struct GNUNET_SERVICE_Client *client);
  * @param bandwidth_in assigned inbound bandwidth
  */
 void
-GAS_scheduling_transmit_address_suggestion(const struct GNUNET_PeerIdentity *peer,
-                                           uint32_t session_id,
-                                           struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                                           struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in);
+GAS_scheduling_transmit_address_suggestion (const struct
+                                            GNUNET_PeerIdentity *peer,
+                                            uint32_t session_id,
+                                            struct GNUNET_BANDWIDTH_Value32NBO
+                                            bandwidth_out,
+                                            struct GNUNET_BANDWIDTH_Value32NBO
+                                            bandwidth_in);
 
 
 /**
@@ -73,7 +76,7 @@ GAS_scheduling_transmit_address_suggestion(const struct GNUNET_PeerIdentity *pee
  * @param m the request message
  */
 void
-GAS_handle_address_add(const struct AddressAddMessage *m);
+GAS_handle_address_add (const struct AddressAddMessage *m);
 
 
 /**
@@ -82,7 +85,7 @@ GAS_handle_address_add(const struct AddressAddMessage *m);
  * @param m the request message
  */
 void
-GAS_handle_address_update(const struct AddressUpdateMessage *m);
+GAS_handle_address_update (const struct AddressUpdateMessage *m);
 
 
 /**
@@ -91,7 +94,7 @@ GAS_handle_address_update(const struct AddressUpdateMessage *m);
  * @param m the request message
  */
 void
-GAS_handle_address_destroyed(const struct AddressDestroyedMessage *m);
+GAS_handle_address_destroyed (const struct AddressDestroyedMessage *m);
 
 
 #endif
diff --git a/src/ats/perf_ats_solver.c b/src/ats/perf_ats_solver.c
index 6a4eadad7..5f10addaf 100644
--- a/src/ats/perf_ats_solver.c
+++ b/src/ats/perf_ats_solver.c
@@ -49,7 +49,8 @@ struct GNUNET_STATISTICS_Handle *GSA_stats;
 /**
  * Handle for ATS address component
  */
-struct PerfHandle {
+struct PerfHandle
+{
   /**
    * Performance peers
    */
@@ -164,7 +165,8 @@ struct PerfHandle {
 /**
  * Data structure to store results for a single iteration
  */
-struct Iteration {
+struct Iteration
+{
   struct Result **results_array;
 
   struct Result **update_results_array;
@@ -174,7 +176,8 @@ struct Iteration {
 /**
  * Result for a solver calculcation
  */
-struct Result {
+struct Result
+{
   /**
    * Previous element in the linked list
    */
@@ -280,7 +283,8 @@ struct Result {
 /**
  * Peer used for the benchmarking
  */
-struct PerfPeer {
+struct PerfPeer
+{
   /**
    * Peer identitity
    */
@@ -313,19 +317,19 @@ static int ret;
  * Do shutdown
  */
 static void
-end_now(int res)
+end_now (int res)
 {
   if (NULL != ph.stat)
-    {
-      GNUNET_STATISTICS_destroy(ph.stat, GNUNET_NO);
-      ph.stat = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (ph.stat, GNUNET_NO);
+    ph.stat = NULL;
+  }
 
-  GNUNET_free_non_null(ph.peers);
-  GNUNET_free_non_null(ph.iterations_results);
+  GNUNET_free_non_null (ph.peers);
+  GNUNET_free_non_null (ph.iterations_results);
 
-  GAS_normalization_stop();
-  GAS_preference_done();
+  GAS_normalization_stop ();
+  GAS_preference_done ();
   ret = res;
 }
 
@@ -336,12 +340,13 @@ end_now(int res)
  * @param cp the number of the peer
  */
 static void
-perf_create_peer(int cp)
+perf_create_peer (int cp)
 {
-  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
-                             &ph.peers[cp].id, sizeof(struct GNUNET_PeerIdentity));
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Creating peer #%u: %s \n", cp,
-             GNUNET_i2s(&ph.peers[cp].id));
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                              &ph.peers[cp].id, sizeof(struct
+                                                       GNUNET_PeerIdentity));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating peer #%u: %s \n", cp,
+              GNUNET_i2s (&ph.peers[cp].id));
 }
 
 
@@ -351,117 +356,118 @@ perf_create_peer(int cp)
  * @param cur the address to update
  */
 static void
-perf_update_address(struct ATS_Address *cur)
+perf_update_address (struct ATS_Address *cur)
 {
   int r_type;
   int abs_val;
   double rel_val;
 
-  r_type = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 2);
+  r_type = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2);
   switch (r_type)
-    {
-    case 0:
-      abs_val = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 100);
-      rel_val = (100 + (double)abs_val) / 100;
-
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Updating peer `%s' address %p type %s abs val %u rel val %.3f\n",
-                 GNUNET_i2s(&cur->peer), cur,
-                 "GNUNET_ATS_QUALITY_NET_DELAY",
-                 abs_val, rel_val);
-      ph.sf->s_address_update_property(ph.sf->cls, cur,
-                                       GNUNET_ATS_QUALITY_NET_DELAY,
-                                       abs_val, rel_val);
-      break;
-
-    case 1:
-      abs_val = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 10);
-      rel_val = (100 + (double)abs_val) / 100;
-
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Updating peer `%s' address %p type %s abs val %u rel val %.3f\n",
-                 GNUNET_i2s(&cur->peer), cur, "GNUNET_ATS_QUALITY_NET_DISTANCE",
-                 abs_val, rel_val);
-      ph.sf->s_address_update_property(ph.sf->cls, cur,
-                                       GNUNET_ATS_QUALITY_NET_DISTANCE,
-                                       abs_val, rel_val);
-      break;
-
-    default:
-      break;
-    }
+  {
+  case 0:
+    abs_val = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100);
+    rel_val = (100 + (double) abs_val) / 100;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Updating peer `%s' address %p type %s abs val %u rel val %.3f\n",
+                GNUNET_i2s (&cur->peer), cur,
+                "GNUNET_ATS_QUALITY_NET_DELAY",
+                abs_val, rel_val);
+    ph.sf->s_address_update_property (ph.sf->cls, cur,
+                                      GNUNET_ATS_QUALITY_NET_DELAY,
+                                      abs_val, rel_val);
+    break;
+
+  case 1:
+    abs_val = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 10);
+    rel_val = (100 + (double) abs_val) / 100;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Updating peer `%s' address %p type %s abs val %u rel val %.3f\n",
+                GNUNET_i2s (&cur->peer), cur, "GNUNET_ATS_QUALITY_NET_DISTANCE",
+                abs_val, rel_val);
+    ph.sf->s_address_update_property (ph.sf->cls, cur,
+                                      GNUNET_ATS_QUALITY_NET_DISTANCE,
+                                      abs_val, rel_val);
+    break;
+
+  default:
+    break;
+  }
 }
 
 
 static void
-bandwidth_changed_cb(void *cls,
-                     struct ATS_Address *address)
+bandwidth_changed_cb (void *cls,
+                      struct ATS_Address *address)
 {
   if ((0 == address->assigned_bw_out) && (0 == address->assigned_bw_in))
     return;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Bandwidth changed addresses %s %p to %u Bps out / %u Bps in\n",
-             GNUNET_i2s(&address->peer),
-             address,
-             address->assigned_bw_out,
-             address->assigned_bw_in);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Bandwidth changed addresses %s %p to %u Bps out / %u Bps in\n",
+              GNUNET_i2s (&address->peer),
+              address,
+              address->assigned_bw_out,
+              address->assigned_bw_in);
   if (GNUNET_YES == ph.bulk_running)
-    GNUNET_break(0);
+    GNUNET_break (0);
   return;
 }
 
 
 static const double *
-get_preferences_cb(void *cls, const struct GNUNET_PeerIdentity *id)
+get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id)
 {
-  return GAS_preference_get_by_peer(NULL, id);
+  return GAS_preference_get_by_peer (NULL, id);
 }
 
 
 static void
-perf_address_initial_update(void *dead,
-                            struct GNUNET_CONTAINER_MultiPeerMap * addresses,
-                            struct ATS_Address *address)
+perf_address_initial_update (void *dead,
+                             struct GNUNET_CONTAINER_MultiPeerMap *addresses,
+                             struct ATS_Address *address)
 {
   double delay;
   double distance;
-  uint32_t random = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 100);
+  uint32_t random = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100);
 
-  delay = (100 + (double)random) / 100;
-  ph.sf->s_address_update_property(ph.sf->cls,
-                                   address, GNUNET_ATS_QUALITY_NET_DELAY,
-                                   100, delay);
+  delay = (100 + (double) random) / 100;
+  ph.sf->s_address_update_property (ph.sf->cls,
+                                    address, GNUNET_ATS_QUALITY_NET_DELAY,
+                                    100, delay);
 
-  random = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 100);
-  distance = (100 + (double)random) / 100;
+  random = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100);
+  distance = (100 + (double) random) / 100;
 
-  ph.sf->s_address_update_property(ph.sf->cls, address,
-                                   GNUNET_ATS_QUALITY_NET_DISTANCE,
-                                   10, distance);
+  ph.sf->s_address_update_property (ph.sf->cls, address,
+                                    GNUNET_ATS_QUALITY_NET_DISTANCE,
+                                    10, distance);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Initial update address %p : %.2f  %.2f\n",
-             address, delay, distance);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Initial update address %p : %.2f  %.2f\n",
+              address, delay, distance);
 }
 
 
-struct DUA_Ctx {
+struct DUA_Ctx
+{
   int r;
   int c_cur_a;
 };
 
 
 static int
-do_update_address(void *cls,
-                  const struct GNUNET_PeerIdentity *pid,
-                  void *value)
+do_update_address (void *cls,
+                   const struct GNUNET_PeerIdentity *pid,
+                   void *value)
 {
   struct DUA_Ctx *ctx = cls;
   struct ATS_Address *addr = value;
 
   if (ctx->c_cur_a == ctx->r)
-    perf_update_address(addr);
+    perf_update_address (addr);
   ctx->c_cur_a++;
   return GNUNET_OK;
 }
@@ -475,7 +481,8 @@ do_update_address(void *cls,
  * @param percentage_peers the percentage of peers to update
  */
 static void
-perf_update_all_addresses(unsigned int cp, unsigned int ca, unsigned int percentage_peers)
+perf_update_all_addresses (unsigned int cp, unsigned int ca, unsigned int
+                           percentage_peers)
 {
   int c_peer;
   int c_select;
@@ -485,9 +492,9 @@ perf_update_all_addresses(unsigned int cp, unsigned int ca, unsigned int percent
   unsigned int m[cp];
   struct DUA_Ctx dua_ctx;
 
-  count = cp * ((double)percentage_peers / 100);
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Updating %u of %u peers \n", count, cp);
+  count = cp * ((double) percentage_peers / 100);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Updating %u of %u peers \n", count, cp);
 
   for (c_peer = 0; c_peer < cp; c_peer++)
     m[c_peer] = 0;
@@ -495,32 +502,32 @@ perf_update_all_addresses(unsigned int cp, unsigned int ca, unsigned int percent
   c_select = 0;
 
   while (c_select < count)
+  {
+    r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, cp);
+    if (0 == m[r])
     {
-      r = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, cp);
-      if (0 == m[r])
-        {
-          m[r] = 1;
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Updating peer [%u] \n", r);
-          c_select++;
-        }
+      m[r] = 1;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Updating peer [%u] \n", r);
+      c_select++;
     }
+  }
   for (c_cur_p = 0; c_cur_p < cp; c_cur_p++)
+  {
+    if (1 == m[c_cur_p])
     {
-      if (1 == m[c_cur_p])
-        {
-          r = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, ca);
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Updating peer [%u] address [%u]\n", c_cur_p, r);
-
-          dua_ctx.c_cur_a = 0;
-          dua_ctx.r = r;
-          GNUNET_CONTAINER_multipeermap_get_multiple(ph.addresses,
-                                                     &ph.peers[c_cur_p].id,
-                                                     &do_update_address,
-                                                     &dua_ctx);
-        }
+      r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, ca);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Updating peer [%u] address [%u]\n", c_cur_p, r);
+
+      dua_ctx.c_cur_a = 0;
+      dua_ctx.r = r;
+      GNUNET_CONTAINER_multipeermap_get_multiple (ph.addresses,
+                                                  &ph.peers[c_cur_p].id,
+                                                  &do_update_address,
+                                                  &dua_ctx);
     }
+  }
 }
 
 /**
@@ -531,14 +538,14 @@ perf_update_all_addresses(unsigned int cp, unsigned int ca, unsigned int percent
  * @return the address
  */
 static struct ATS_Address *
-perf_create_address(int cp, int ca)
+perf_create_address (int cp, int ca)
 {
   struct ATS_Address *a;
 
-  a = create_address(&ph.peers[cp].id,
-                     "Test 1", "test 1", strlen("test 1") + 1, 0);
-  GNUNET_CONTAINER_multipeermap_put(ph.addresses, &ph.peers[cp].id, a,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  a = create_address (&ph.peers[cp].id,
+                      "Test 1", "test 1", strlen ("test 1") + 1, 0);
+  GNUNET_CONTAINER_multipeermap_put (ph.addresses, &ph.peers[cp].id, a,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   return a;
 }
 
@@ -551,252 +558,264 @@ perf_create_address(int cp, int ca)
  * @param add additional solver information
  */
 static void
-solver_info_cb(void *cls,
-               enum GAS_Solver_Operation op,
-               enum GAS_Solver_Status stat,
-               enum GAS_Solver_Additional_Information add)
+solver_info_cb (void *cls,
+                enum GAS_Solver_Operation op,
+                enum GAS_Solver_Status stat,
+                enum GAS_Solver_Additional_Information add)
 {
   char *add_info;
 
   switch (add)
-    {
-    case GAS_INFO_NONE:
-      add_info = "GAS_INFO_NONE";
-      break;
+  {
+  case GAS_INFO_NONE:
+    add_info = "GAS_INFO_NONE";
+    break;
 
-    case GAS_INFO_FULL:
-      add_info = "GAS_INFO_MLP_FULL";
-      break;
+  case GAS_INFO_FULL:
+    add_info = "GAS_INFO_MLP_FULL";
+    break;
 
-    case GAS_INFO_UPDATED:
-      add_info = "GAS_INFO_MLP_UPDATED";
-      break;
+  case GAS_INFO_UPDATED:
+    add_info = "GAS_INFO_MLP_UPDATED";
+    break;
 
-    case GAS_INFO_PROP_ALL:
-      add_info = "GAS_INFO_PROP_ALL";
-      break;
+  case GAS_INFO_PROP_ALL:
+    add_info = "GAS_INFO_PROP_ALL";
+    break;
 
-    case GAS_INFO_PROP_SINGLE:
-      add_info = "GAS_INFO_PROP_SINGLE";
-      break;
+  case GAS_INFO_PROP_SINGLE:
+    add_info = "GAS_INFO_PROP_SINGLE";
+    break;
 
-    default:
-      add_info = "INVALID";
-      break;
-    }
+  default:
+    add_info = "INVALID";
+    break;
+  }
 
   struct Result *tmp;
   switch (op)
+  {
+  case GAS_OP_SOLVE_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s' `%s'\n",
+                "GAS_OP_SOLVE_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
+    if (GNUNET_NO == ph.expecting_solution)
     {
-    case GAS_OP_SOLVE_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s' `%s'\n", "GAS_OP_SOLVE_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
-      if (GNUNET_NO == ph.expecting_solution)
-        {
-          /* We do not expect a solution at the moment */
-          GNUNET_break(0);
-          return;
-        }
-
-      if ((GAS_STAT_SUCCESS == stat) && (NULL == ph.current_result))
-        {
-          tmp = GNUNET_new(struct Result);
-          /* Create new result */
-          if ((add == GAS_INFO_UPDATED) || (GNUNET_YES == ph.performed_update))
-            {
-              ph.current_result = tmp;
-              //fprintf (stderr,"UPDATE %u %u\n",ph.current_iteration-1, ph.current_p);
-              ph.iterations_results[ph.current_iteration - 1].update_results_array[ph.current_p] = tmp;
-            }
-          else
-            {
-              ph.current_result = tmp;
-              //fprintf (stderr,"FULL %u %u\n",ph.current_iteration-1, ph.current_p);
-              ph.iterations_results[ph.current_iteration - 1].results_array[ph.current_p] = tmp;
-            }
-
-          ph.current_result->addresses = ph.current_a;
-          ph.current_result->peers = ph.current_p;
-          ph.current_result->s_total = GNUNET_TIME_absolute_get();
-          ph.current_result->d_total_full = GNUNET_TIME_UNIT_FOREVER_REL;
-          ph.current_result->d_setup_full = GNUNET_TIME_UNIT_FOREVER_REL;
-          ph.current_result->d_lp_full = GNUNET_TIME_UNIT_FOREVER_REL;
-          ph.current_result->d_mlp_full = GNUNET_TIME_UNIT_FOREVER_REL;
-          ph.current_result->info = add;
-          if ((add == GAS_INFO_UPDATED) || (GNUNET_YES == ph.performed_update))
-            {
-              ph.current_result->update = GNUNET_YES;
-            }
-          else
-            {
-              ph.current_result->update = GNUNET_NO;
-            }
-        }
+      /* We do not expect a solution at the moment */
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s', `%s'\n", "GAS_OP_SOLVE_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
-      if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
-        {
-          /* We do not expect a solution at the moment */
-          GNUNET_break(0);
-          return;
-        }
-
-      if (GAS_STAT_SUCCESS == stat)
-        ph.current_result->valid = GNUNET_YES;
+    if ((GAS_STAT_SUCCESS == stat) && (NULL == ph.current_result))
+    {
+      tmp = GNUNET_new (struct Result);
+      /* Create new result */
+      if ((add == GAS_INFO_UPDATED) || (GNUNET_YES == ph.performed_update))
+      {
+        ph.current_result = tmp;
+        // fprintf (stderr,"UPDATE %u %u\n",ph.current_iteration-1, ph.current_p);
+        ph.iterations_results[ph.current_iteration
+                              - 1].update_results_array[ph.current_p] = tmp;
+      }
       else
-        ph.current_result->valid = GNUNET_NO;
+      {
+        ph.current_result = tmp;
+        // fprintf (stderr,"FULL %u %u\n",ph.current_iteration-1, ph.current_p);
+        ph.iterations_results[ph.current_iteration
+                              - 1].results_array[ph.current_p] = tmp;
+      }
+
+      ph.current_result->addresses = ph.current_a;
+      ph.current_result->peers = ph.current_p;
+      ph.current_result->s_total = GNUNET_TIME_absolute_get ();
+      ph.current_result->d_total_full = GNUNET_TIME_UNIT_FOREVER_REL;
+      ph.current_result->d_setup_full = GNUNET_TIME_UNIT_FOREVER_REL;
+      ph.current_result->d_lp_full = GNUNET_TIME_UNIT_FOREVER_REL;
+      ph.current_result->d_mlp_full = GNUNET_TIME_UNIT_FOREVER_REL;
+      ph.current_result->info = add;
+      if ((add == GAS_INFO_UPDATED) || (GNUNET_YES == ph.performed_update))
+      {
+        ph.current_result->update = GNUNET_YES;
+      }
+      else
+      {
+        ph.current_result->update = GNUNET_NO;
+      }
+    }
+    return;
 
-      if (NULL != ph.current_result)
-        {
-          /* Finalize result */
-          ph.current_result->e_total = GNUNET_TIME_absolute_get();
-          ph.current_result->d_total_full = GNUNET_TIME_absolute_get_difference(
-            ph.current_result->s_total, ph.current_result->e_total);
-        }
-      ph.current_result = NULL;
+  case GAS_OP_SOLVE_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s', `%s'\n",
+                "GAS_OP_SOLVE_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
+    if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
+    {
+      /* We do not expect a solution at the moment */
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_SETUP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
-        {
-          GNUNET_break(0);
-          return;
-        }
+    if (GAS_STAT_SUCCESS == stat)
+      ph.current_result->valid = GNUNET_YES;
+    else
+      ph.current_result->valid = GNUNET_NO;
 
-      if (GAS_STAT_SUCCESS == stat)
-        ph.current_result->valid = GNUNET_YES;
-      else
-        ph.current_result->valid = GNUNET_NO;
+    if (NULL != ph.current_result)
+    {
+      /* Finalize result */
+      ph.current_result->e_total = GNUNET_TIME_absolute_get ();
+      ph.current_result->d_total_full = GNUNET_TIME_absolute_get_difference (
+        ph.current_result->s_total, ph.current_result->e_total);
+    }
+    ph.current_result = NULL;
+    return;
 
-      ph.current_result->s_setup = GNUNET_TIME_absolute_get();
+  case GAS_OP_SOLVE_SETUP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_SETUP_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
+    {
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_SETUP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
-        {
-          GNUNET_break(0);
-          return;
-        }
+    if (GAS_STAT_SUCCESS == stat)
+      ph.current_result->valid = GNUNET_YES;
+    else
+      ph.current_result->valid = GNUNET_NO;
 
-      if (GAS_STAT_SUCCESS == stat)
-        ph.current_result->valid = GNUNET_YES;
-      else
-        ph.current_result->valid = GNUNET_NO;
+    ph.current_result->s_setup = GNUNET_TIME_absolute_get ();
+    return;
 
-      ph.current_result->e_setup = GNUNET_TIME_absolute_get();
-      ph.current_result->d_setup_full = GNUNET_TIME_absolute_get_difference(
-        ph.current_result->s_setup, ph.current_result->e_setup);
+  case GAS_OP_SOLVE_SETUP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_SETUP_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
+    {
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_MLP_LP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
-        {
-          GNUNET_break(0);
-          return;
-        }
+    if (GAS_STAT_SUCCESS == stat)
+      ph.current_result->valid = GNUNET_YES;
+    else
+      ph.current_result->valid = GNUNET_NO;
 
-      if (GAS_STAT_SUCCESS == stat)
-        ph.current_result->valid = GNUNET_YES;
-      else
-        ph.current_result->valid = GNUNET_NO;
+    ph.current_result->e_setup = GNUNET_TIME_absolute_get ();
+    ph.current_result->d_setup_full = GNUNET_TIME_absolute_get_difference (
+      ph.current_result->s_setup, ph.current_result->e_setup);
+    return;
 
-      ph.current_result->s_lp = GNUNET_TIME_absolute_get();
+  case GAS_OP_SOLVE_MLP_LP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_LP_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
+    {
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_MLP_LP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
-        {
-          GNUNET_break(0);
-          return;
-        }
+    if (GAS_STAT_SUCCESS == stat)
+      ph.current_result->valid = GNUNET_YES;
+    else
+      ph.current_result->valid = GNUNET_NO;
 
-      if (GAS_STAT_SUCCESS == stat)
-        ph.current_result->valid = GNUNET_YES;
-      else
-        ph.current_result->valid = GNUNET_NO;
+    ph.current_result->s_lp = GNUNET_TIME_absolute_get ();
+    return;
 
-      ph.current_result->e_lp = GNUNET_TIME_absolute_get();
-      ph.current_result->d_lp_full = GNUNET_TIME_absolute_get_difference(
-        ph.current_result->s_lp, ph.current_result->e_lp);
+  case GAS_OP_SOLVE_MLP_LP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_LP_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
+    {
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_MLP_MLP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
-        {
-          GNUNET_break(0);
-          return;
-        }
+    if (GAS_STAT_SUCCESS == stat)
+      ph.current_result->valid = GNUNET_YES;
+    else
+      ph.current_result->valid = GNUNET_NO;
 
-      if (GAS_STAT_SUCCESS == stat)
-        ph.current_result->valid = GNUNET_YES;
-      else
-        ph.current_result->valid = GNUNET_NO;
+    ph.current_result->e_lp = GNUNET_TIME_absolute_get ();
+    ph.current_result->d_lp_full = GNUNET_TIME_absolute_get_difference (
+      ph.current_result->s_lp, ph.current_result->e_lp);
+    return;
 
-      ph.current_result->s_mlp = GNUNET_TIME_absolute_get();
+  case GAS_OP_SOLVE_MLP_MLP_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_MLP_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
+    {
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_MLP_MLP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
-        {
-          GNUNET_break(0);
-          return;
-        }
+    if (GAS_STAT_SUCCESS == stat)
+      ph.current_result->valid = GNUNET_YES;
+    else
+      ph.current_result->valid = GNUNET_NO;
 
-      if (GAS_STAT_SUCCESS == stat)
-        ph.current_result->valid = GNUNET_YES;
-      else
-        ph.current_result->valid = GNUNET_NO;
+    ph.current_result->s_mlp = GNUNET_TIME_absolute_get ();
+    return;
 
-      ph.current_result->e_mlp = GNUNET_TIME_absolute_get();
-      ph.current_result->d_mlp_full = GNUNET_TIME_absolute_get_difference(
-        ph.current_result->s_mlp, ph.current_result->e_mlp);
+  case GAS_OP_SOLVE_MLP_MLP_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_MLP_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result))
+    {
+      GNUNET_break (0);
       return;
+    }
 
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      return;
+    if (GAS_STAT_SUCCESS == stat)
+      ph.current_result->valid = GNUNET_YES;
+    else
+      ph.current_result->valid = GNUNET_NO;
 
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
-                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
-      if (GAS_STAT_SUCCESS != stat)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Solver `%s' failed to update problem with %u peers and %u address!\n",
-                     ph.ats_string, ph.current_p, ph.current_a);
-        }
+    ph.current_result->e_mlp = GNUNET_TIME_absolute_get ();
+    ph.current_result->d_mlp_full = GNUNET_TIME_absolute_get_difference (
+      ph.current_result->s_mlp, ph.current_result->e_mlp);
+    return;
 
-      return;
+  case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    return;
 
-    default:
-      break;
+  case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Solver notifies `%s' with result `%s'\n",
+                "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
+                (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
+    if (GAS_STAT_SUCCESS != stat)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Solver `%s' failed to update problem with %u peers and %u address!\n",
+                  ph.ats_string, ph.current_p, ph.current_a);
     }
+
+    return;
+
+  default:
+    break;
+  }
 }
 
 /**
@@ -805,82 +824,86 @@ solver_info_cb(void *cls,
  * @param iteration the iteration to evaluate
  */
 static void
-evaluate(int iteration)
+evaluate (int iteration)
 {
   struct Result *cur;
   int cp;
 
   for (cp = ph.N_peers_start; cp <= ph.N_peers_end; cp++)
+  {
+    cur = ph.iterations_results[ph.current_iteration - 1].results_array[cp];
+    if (0 == cp)
+      continue;
+    if (NULL == cur)
     {
-      cur = ph.iterations_results[ph.current_iteration - 1].results_array[cp];
-      if (0 == cp)
-        continue;
-      if (NULL == cur)
-        {
-          GNUNET_break(0);
-          fprintf(stderr,
-                  "Missing result for %u peers\n", cp);
-          continue;
-        }
+      GNUNET_break (0);
+      fprintf (stderr,
+               "Missing result for %u peers\n", cp);
+      continue;
+    }
 
 
-      if (GNUNET_NO == cur->valid)
-        {
-          fprintf(stderr,
-                  "Total time to solve %s for %u peers %u addresses: %s\n",
-                  (GNUNET_YES == cur->update) ? "updated" : "full",
-                  cur->peers, cur->addresses, "Failed to solve!");
-          continue;
-        }
+    if (GNUNET_NO == cur->valid)
+    {
+      fprintf (stderr,
+               "Total time to solve %s for %u peers %u addresses: %s\n",
+               (GNUNET_YES == cur->update) ? "updated" : "full",
+               cur->peers, cur->addresses, "Failed to solve!");
+      continue;
+    }
 
 
-      if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_total_full.rel_value_us)
-        {
-          fprintf(stderr,
-                  "Total time to solve %s for %u peers %u addresses: %llu us\n",
-                  (GNUNET_YES == cur->update) ? "updated" : "full",
-                  cur->peers, cur->addresses,
-                  (unsigned long long)cur->d_total_full.rel_value_us);
-        }
+    if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
+        cur->d_total_full.rel_value_us)
+    {
+      fprintf (stderr,
+               "Total time to solve %s for %u peers %u addresses: %llu us\n",
+               (GNUNET_YES == cur->update) ? "updated" : "full",
+               cur->peers, cur->addresses,
+               (unsigned long long) cur->d_total_full.rel_value_us);
+    }
 
 
-      if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_setup_full.rel_value_us)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     "Total time to setup %s %u peers %u addresses: %llu us\n",
-                     (GNUNET_YES == cur->update) ? "updated" : "full",
-                     cur->peers, cur->addresses,
-                     (unsigned long long)cur->d_setup_full.rel_value_us);
-        }
+    if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
+        cur->d_setup_full.rel_value_us)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Total time to setup %s %u peers %u addresses: %llu us\n",
+                  (GNUNET_YES == cur->update) ? "updated" : "full",
+                  cur->peers, cur->addresses,
+                  (unsigned long long) cur->d_setup_full.rel_value_us);
+    }
 
-      if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_lp_full.rel_value_us)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     "Total time to solve %s LP for %u peers %u addresses: %llu us\n",
-                     (GNUNET_YES == cur->update) ? "updated" : "full",
-                     cur->peers,
-                     cur->addresses,
-                     (unsigned long long )cur->d_lp_full.rel_value_us);
-        }
+    if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
+        cur->d_lp_full.rel_value_us)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Total time to solve %s LP for %u peers %u addresses: %llu us\n",
+                  (GNUNET_YES == cur->update) ? "updated" : "full",
+                  cur->peers,
+                  cur->addresses,
+                  (unsigned long long ) cur->d_lp_full.rel_value_us);
+    }
 
-      if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_mlp_full.rel_value_us)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     "Total time to solve %s MLP for %u peers %u addresses: %llu us\n",
-                     (GNUNET_YES == cur->update) ? "updated" : "full",
-                     cur->peers, cur->addresses,
-                     (unsigned long long )cur->d_mlp_full.rel_value_us);
-        }
+    if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
+        cur->d_mlp_full.rel_value_us)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Total time to solve %s MLP for %u peers %u addresses: %llu us\n",
+                  (GNUNET_YES == cur->update) ? "updated" : "full",
+                  cur->peers, cur->addresses,
+                  (unsigned long long ) cur->d_mlp_full.rel_value_us);
     }
+  }
 }
 
 
 static unsigned int
-get_connectivity_cb(void *cls,
-                    const struct GNUNET_PeerIdentity *peer)
+get_connectivity_cb (void *cls,
+                     const struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CONTAINER_multipeermap_contains(ph.addresses,
-                                                peer);
+  return GNUNET_CONTAINER_multipeermap_contains (ph.addresses,
+                                                 peer);
 }
 
 
@@ -888,16 +911,16 @@ get_connectivity_cb(void *cls,
  * Evaluate average results for all iterations
  */
 static void
-write_all_iterations(void)
+write_all_iterations (void)
 {
   int c_iteration;
   int c_peer;
 
   struct GNUNET_DISK_FileHandle *f_full;
   struct GNUNET_DISK_FileHandle *f_update;
-  char * data_fn_full;
-  char * data_fn_update;
-  char * data;
+  char *data_fn_full;
+  char *data_fn_update;
+  char *data;
 
   f_full = NULL;
   f_update = NULL;
@@ -907,179 +930,192 @@ write_all_iterations(void)
   if (GNUNET_NO == ph.create_datafile)
     return;
 
-  GNUNET_asprintf(&data_fn_full,
-                  "perf_%s_full_%u-%u_%u_%u.data",
-                  ph.ats_string,
-                  ph.total_iterations,
-                  ph.N_peers_start,
-                  ph.N_peers_end,
-                  ph.N_address);
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Using data file `%s'\n",
-             data_fn_full);
-
-  f_full = GNUNET_DISK_file_open(data_fn_full,
-                                 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
-                                 GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+  GNUNET_asprintf (&data_fn_full,
+                   "perf_%s_full_%u-%u_%u_%u.data",
+                   ph.ats_string,
+                   ph.total_iterations,
+                   ph.N_peers_start,
+                   ph.N_peers_end,
+                   ph.N_address);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Using data file `%s'\n",
+              data_fn_full);
+
+  f_full = GNUNET_DISK_file_open (data_fn_full,
+                                  GNUNET_DISK_OPEN_WRITE
+                                  | GNUNET_DISK_OPEN_CREATE,
+                                  GNUNET_DISK_PERM_USER_EXEC
+                                  | GNUNET_DISK_PERM_USER_READ
+                                  | GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == f_full)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Cannot open data file `%s'\n",
-                 data_fn_full);
-      GNUNET_free(data_fn_full);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Cannot open data file `%s'\n",
+                data_fn_full);
+    GNUNET_free (data_fn_full);
+    return;
+  }
 
-  data = "#peers;addresses;time total in us;#time setup in us;#time lp in us;#time mlp in us;\n";
-  if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_full, data, strlen(data)))
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-               "Cannot write data to log file `%s'\n",
-               data_fn_full);
+  data =
+    "#peers;addresses;time total in us;#time setup in us;#time lp in us;#time mlp in us;\n";
+  if (GNUNET_SYSERR == GNUNET_DISK_file_write (f_full, data, strlen (data)))
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Cannot write data to log file `%s'\n",
+                data_fn_full);
 
   data_fn_update = NULL;
   if (GNUNET_YES == ph.measure_updates)
+  {
+    GNUNET_asprintf (&data_fn_update, "perf_%s_update_%u-%u_%u_%u.data",
+                     ph.ats_string,
+                     ph.total_iterations,
+                     ph.N_peers_start,
+                     ph.N_peers_end,
+                     ph.N_address);
+    f_update = GNUNET_DISK_file_open (data_fn_update,
+                                      GNUNET_DISK_OPEN_WRITE
+                                      | GNUNET_DISK_OPEN_CREATE,
+                                      GNUNET_DISK_PERM_USER_EXEC
+                                      | GNUNET_DISK_PERM_USER_READ
+                                      | GNUNET_DISK_PERM_USER_WRITE);
+    if (NULL == f_update)
     {
-      GNUNET_asprintf(&data_fn_update, "perf_%s_update_%u-%u_%u_%u.data",
-                      ph.ats_string,
-                      ph.total_iterations,
-                      ph.N_peers_start,
-                      ph.N_peers_end,
-                      ph.N_address);
-      f_update = GNUNET_DISK_file_open(data_fn_update,
-                                       GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
-                                       GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
-      if (NULL == f_update)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Cannot open gnuplot file `%s'\n", data_fn_update);
-          GNUNET_free(data_fn_update);
-          if (NULL != f_full)
-            GNUNET_DISK_file_close(f_full);
-          GNUNET_free(data_fn_full);
-          return;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Cannot open gnuplot file `%s'\n", data_fn_update);
+      GNUNET_free (data_fn_update);
+      if (NULL != f_full)
+        GNUNET_DISK_file_close (f_full);
+      GNUNET_free (data_fn_full);
+      return;
+    }
 
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Using update data file `%s'\n",
-                 data_fn_update);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Using update data file `%s'\n",
+                data_fn_update);
 
-      data = "#peers;addresses;time total in us;#time setup in us;#time lp in us;#time mlp in us;\n";
-      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_update, data, strlen(data)))
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                   "Cannot write data to log file `%s'\n",
-                   data_fn_update);
-    }
+    data =
+      "#peers;addresses;time total in us;#time setup in us;#time lp in us;#time mlp in us;\n";
+    if (GNUNET_SYSERR == GNUNET_DISK_file_write (f_update, data, strlen (data)))
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Cannot write data to log file `%s'\n",
+                  data_fn_update);
+  }
 
   for (c_peer = ph.N_peers_start; c_peer <= ph.N_peers_end; c_peer++)
+  {
+    char *data_str;
+    char *data_tmp;
+    char *data_upd_str;
+    char *data_upd_tmp;
+    GNUNET_asprintf (&data_str, "%u;%u", c_peer, ph.N_address);
+    if (ph.measure_updates)
+      GNUNET_asprintf (&data_upd_str, "%u;%u", c_peer, ph.N_address);
+    for (c_iteration = 0; c_iteration < ph.total_iterations; c_iteration++)
     {
-      char * data_str;
-      char * data_tmp;
-      char * data_upd_str;
-      char * data_upd_tmp;
-      GNUNET_asprintf(&data_str, "%u;%u", c_peer, ph.N_address);
-      if (ph.measure_updates)
-        GNUNET_asprintf(&data_upd_str, "%u;%u", c_peer, ph.N_address);
-      for (c_iteration = 0; c_iteration < ph.total_iterations; c_iteration++)
-        {
-          struct Result *cur_full_res;
-          struct Result *cur_upd_res;
-
-
-
-          //fprintf (stderr, "P: %u I: %u  == %p \n", c_peer, c_iteration, cur_res);
-          cur_full_res = ph.iterations_results[c_iteration].results_array[c_peer];
-          if (c_peer == 0)
-            continue;
-          if (NULL == cur_full_res)
-            continue;
-
-          if (ph.measure_updates)
-            {
-              cur_upd_res = ph.iterations_results[c_iteration].update_results_array[c_peer];
-              data_upd_tmp = GNUNET_strdup(data_upd_str);
-              GNUNET_free(data_upd_str);
-              if (GNUNET_YES == cur_full_res->valid)
-                {
-                  GNUNET_asprintf(&data_upd_str, "%s;%llu", data_upd_tmp,
-                                  (NULL == cur_upd_res) ? 0 : cur_upd_res->d_total_full.rel_value_us);
-                }
-              else
-                {
-                  GNUNET_asprintf(&data_upd_str, "%s;", data_upd_tmp);
-                }
-              GNUNET_free(data_upd_tmp);
-            }
-
-          //fprintf (stderr, "P: %u I: %u: P %i  A %i\n", c_peer, c_iteration, cur_res->peers, cur_res->addresses);
-          //fprintf (stderr, "D total: %llu\n", (long long unsigned int) cur_res->d_total.rel_value_us);
-
-          data_tmp = GNUNET_strdup(data_str);
-          GNUNET_free(data_str);
-          if (GNUNET_YES == cur_full_res->valid)
-            {
-              GNUNET_asprintf(&data_str, "%s;%llu", data_tmp,
-                              cur_full_res->d_total_full.rel_value_us);
-            }
-          else
-            {
-              GNUNET_asprintf(&data_str, "%s;", data_tmp);
-            }
-
-          GNUNET_free(data_tmp);
-        }
-      data_tmp = GNUNET_strdup(data_str);
-      GNUNET_free(data_str);
-      GNUNET_asprintf(&data_str, "%s\n", data_tmp);
-      GNUNET_free(data_tmp);
+      struct Result *cur_full_res;
+      struct Result *cur_upd_res;
 
-      fprintf(stderr, "Result full solution: %s\n", data_str);
-      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_full, data_str, strlen(data_str)))
-        GNUNET_break(0);
-      GNUNET_free(data_str);
+
+
+      // fprintf (stderr, "P: %u I: %u  == %p \n", c_peer, c_iteration, cur_res);
+      cur_full_res = ph.iterations_results[c_iteration].results_array[c_peer];
+      if (c_peer == 0)
+        continue;
+      if (NULL == cur_full_res)
+        continue;
 
       if (ph.measure_updates)
+      {
+        cur_upd_res =
+          ph.iterations_results[c_iteration].update_results_array[c_peer];
+        data_upd_tmp = GNUNET_strdup (data_upd_str);
+        GNUNET_free (data_upd_str);
+        if (GNUNET_YES == cur_full_res->valid)
         {
-          data_upd_tmp = GNUNET_strdup(data_upd_str);
-          GNUNET_free(data_upd_str);
-          GNUNET_asprintf(&data_upd_str, "%s\n", data_upd_tmp);
-          GNUNET_free(data_upd_tmp);
-
-          fprintf(stderr, "Result updated solution: `%s'\n", data_upd_str);
-          if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_update, data_upd_str, strlen(data_upd_str)))
-            GNUNET_break(0);
-          GNUNET_free(data_upd_str);
+          GNUNET_asprintf (&data_upd_str, "%s;%llu", data_upd_tmp,
+                           (NULL == cur_upd_res) ? 0 :
+                           cur_upd_res->d_total_full.rel_value_us);
         }
-    }
-
-  if ((NULL != f_full) && (GNUNET_SYSERR == GNUNET_DISK_file_close(f_full)))
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot close log file `%s'\n",
-               data_fn_full);
-  GNUNET_free_non_null(data_fn_full);
+        else
+        {
+          GNUNET_asprintf (&data_upd_str, "%s;", data_upd_tmp);
+        }
+        GNUNET_free (data_upd_tmp);
+      }
+
+      // fprintf (stderr, "P: %u I: %u: P %i  A %i\n", c_peer, c_iteration, cur_res->peers, cur_res->addresses);
+      // fprintf (stderr, "D total: %llu\n", (long long unsigned int) cur_res->d_total.rel_value_us);
+
+      data_tmp = GNUNET_strdup (data_str);
+      GNUNET_free (data_str);
+      if (GNUNET_YES == cur_full_res->valid)
+      {
+        GNUNET_asprintf (&data_str, "%s;%llu", data_tmp,
+                         cur_full_res->d_total_full.rel_value_us);
+      }
+      else
+      {
+        GNUNET_asprintf (&data_str, "%s;", data_tmp);
+      }
 
-  if ((NULL != f_update) && (GNUNET_SYSERR == GNUNET_DISK_file_close(f_update)))
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot close log file `%s'\n",
-               data_fn_update);
-  GNUNET_free_non_null(data_fn_update);
+      GNUNET_free (data_tmp);
+    }
+    data_tmp = GNUNET_strdup (data_str);
+    GNUNET_free (data_str);
+    GNUNET_asprintf (&data_str, "%s\n", data_tmp);
+    GNUNET_free (data_tmp);
+
+    fprintf (stderr, "Result full solution: %s\n", data_str);
+    if (GNUNET_SYSERR == GNUNET_DISK_file_write (f_full, data_str, strlen (
+                                                   data_str)))
+      GNUNET_break (0);
+    GNUNET_free (data_str);
+
+    if (ph.measure_updates)
+    {
+      data_upd_tmp = GNUNET_strdup (data_upd_str);
+      GNUNET_free (data_upd_str);
+      GNUNET_asprintf (&data_upd_str, "%s\n", data_upd_tmp);
+      GNUNET_free (data_upd_tmp);
+
+      fprintf (stderr, "Result updated solution: `%s'\n", data_upd_str);
+      if (GNUNET_SYSERR == GNUNET_DISK_file_write (f_update, data_upd_str,
+                                                   strlen (data_upd_str)))
+        GNUNET_break (0);
+      GNUNET_free (data_upd_str);
+    }
+  }
+
+  if ((NULL != f_full) && (GNUNET_SYSERR == GNUNET_DISK_file_close (f_full)))
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close log file `%s'\n",
+                data_fn_full);
+  GNUNET_free_non_null (data_fn_full);
+
+  if ((NULL != f_update) && (GNUNET_SYSERR == GNUNET_DISK_file_close (
+                               f_update)))
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close log file `%s'\n",
+                data_fn_update);
+  GNUNET_free_non_null (data_fn_update);
 }
 
 
 static int
-do_delete_address(void *cls,
-                  const struct GNUNET_PeerIdentity *pid,
-                  void *value)
+do_delete_address (void *cls,
+                   const struct GNUNET_PeerIdentity *pid,
+                   void *value)
 {
   struct ATS_Address *cur = value;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Deleting addresses for peer %u\n",
-             pid);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_remove(ph.addresses,
-                                                     pid,
-                                                     cur));
-  ph.sf->s_del(ph.sf->cls, cur);
-  GNUNET_free_non_null(cur->atsi);
-  GNUNET_free(cur);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Deleting addresses for peer %u\n",
+              pid);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_remove (ph.addresses,
+                                                       pid,
+                                                       cur));
+  ph.sf->s_del (ph.sf->cls, cur);
+  GNUNET_free_non_null (cur->atsi);
+  GNUNET_free (cur);
   return GNUNET_OK;
 }
 
@@ -1088,134 +1124,139 @@ do_delete_address(void *cls,
  * Run a performance iteration
  */
 static void
-perf_run_iteration(void)
+perf_run_iteration (void)
 {
   int cp;
   int ca;
   int count_p = ph.N_peers_end;
   int count_a = ph.N_address;
-  struct ATS_Address * cur_addr;
+  struct ATS_Address *cur_addr;
   uint32_t net;
 
-  ph.iterations_results[ph.current_iteration - 1].results_array = GNUNET_malloc((count_p + 1) * sizeof(struct Result *));
+  ph.iterations_results[ph.current_iteration - 1].results_array =
+    GNUNET_malloc ((count_p + 1) * sizeof(struct Result *));
   if (ph.measure_updates)
-    ph.iterations_results[ph.current_iteration - 1].update_results_array = GNUNET_malloc((count_p + 1) * sizeof(struct Result *));
-  ph.peers = GNUNET_malloc((count_p) * sizeof(struct PerfPeer));
+    ph.iterations_results[ph.current_iteration - 1].update_results_array =
+      GNUNET_malloc ((count_p + 1) * sizeof(struct Result *));
+  ph.peers = GNUNET_malloc ((count_p) * sizeof(struct PerfPeer));
   for (cp = 0; cp < count_p; cp++)
-    perf_create_peer(cp);
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Iteration %u of %u, added %u peers\n", ph.current_iteration, ph.total_iterations, cp);
+    perf_create_peer (cp);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Iteration %u of %u, added %u peers\n", ph.current_iteration,
+              ph.total_iterations, cp);
 
   for (cp = 0; cp < count_p; cp++)
+  {
+    fprintf (stderr, "%u..", cp);
+    if (GNUNET_NO == ph.bulk_running)
     {
-      fprintf(stderr, "%u..", cp);
-      if (GNUNET_NO == ph.bulk_running)
-        {
-          ph.bulk_running = GNUNET_YES;
-          ph.sf->s_bulk_start(ph.sf->cls);
-        }
-      ph.current_p = cp + 1;
-      for (ca = 0; ca < count_a; ca++)
-        {
-          cur_addr = perf_create_address(cp, ca);
-          /* Add address */
-
-          /* Random network selection */
-          //net = 1 + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_NT_COUNT - 1);
-          /* Random equally distributed network selection */
-          net = 1 + (ca % (GNUNET_NT_COUNT - 1));
-          /* fprintf (stderr, "Network: %u `%s'\n",
-           * mod_net , GNUNET_NT_to_string(mod_net)); */
-
-          cur_addr->atsi = GNUNET_new(struct GNUNET_ATS_Information);
-          cur_addr->atsi_count = 1;
-          cur_addr->atsi[0].type = htonl(GNUNET_ATS_NETWORK_TYPE);
-          cur_addr->atsi[0].value = htonl(net);
-          ph.sf->s_add(ph.sf->cls, cur_addr, net);
-
-          ph.current_a = ca + 1;
-          perf_address_initial_update(NULL, ph.addresses, cur_addr);
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     "Adding address for peer %u address %u in network %s\n", cp, ca,
-                     GNUNET_NT_to_string(net));
-        }
-      /* Notify solver about request */
-      ph.sf->s_get(ph.sf->cls, &ph.peers[cp].id);
-
-      if (cp + 1 >= ph.N_peers_start)
-        {
-          /* Disable bulk to solve the problem */
-          if (GNUNET_YES == ph.bulk_running)
-            {
-              ph.expecting_solution = GNUNET_YES;
-              ph.bulk_running = GNUNET_NO;
-              ph.sf->s_bulk_stop(ph.sf->cls);
-            }
-          else
-            GNUNET_break(0);
-
-          /* Problem is solved by the solver here due to unlocking */
-          ph.expecting_solution = GNUNET_NO;
-
-          /* Update the problem */
-          if ((0 < ph.opt_update_percent) && (GNUNET_YES == ph.measure_updates))
-            {
-              /* Update */
-              GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                         "Updating problem with %u peers and %u addresses\n", cp + 1, ca);
-
-              ph.expecting_solution = GNUNET_YES;
-              ph.performed_update = GNUNET_YES;
-              if (GNUNET_NO == ph.bulk_running)
-                {
-                  ph.bulk_running = GNUNET_YES;
-                  ph.sf->s_bulk_start(ph.sf->cls);
-                }
-              perf_update_all_addresses(cp + 1, ca, ph.opt_update_percent);
-              ph.bulk_running = GNUNET_NO;
-              ph.sf->s_bulk_stop(ph.sf->cls);
-              /* Problem is solved by the solver here due to unlocking */
-              ph.performed_update = GNUNET_NO;
-              ph.expecting_solution = GNUNET_NO;
-            }
-          GNUNET_assert(GNUNET_NO == ph.bulk_running);
-        }
+      ph.bulk_running = GNUNET_YES;
+      ph.sf->s_bulk_start (ph.sf->cls);
     }
-  fprintf(stderr, "\n");
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Done, cleaning up addresses\n");
-  if (GNUNET_NO == ph.bulk_running)
+    ph.current_p = cp + 1;
+    for (ca = 0; ca < count_a; ca++)
     {
-      ph.sf->s_bulk_start(ph.sf->cls);
-      ph.bulk_running = GNUNET_YES;
+      cur_addr = perf_create_address (cp, ca);
+      /* Add address */
+
+      /* Random network selection */
+      // net = 1 + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_NT_COUNT - 1);
+      /* Random equally distributed network selection */
+      net = 1 + (ca % (GNUNET_NT_COUNT - 1));
+      /* fprintf (stderr, "Network: %u `%s'\n",
+       * mod_net , GNUNET_NT_to_string(mod_net)); */
+
+      cur_addr->atsi = GNUNET_new (struct GNUNET_ATS_Information);
+      cur_addr->atsi_count = 1;
+      cur_addr->atsi[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
+      cur_addr->atsi[0].value = htonl (net);
+      ph.sf->s_add (ph.sf->cls, cur_addr, net);
+
+      ph.current_a = ca + 1;
+      perf_address_initial_update (NULL, ph.addresses, cur_addr);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Adding address for peer %u address %u in network %s\n", cp,
+                  ca,
+                  GNUNET_NT_to_string (net));
     }
+    /* Notify solver about request */
+    ph.sf->s_get (ph.sf->cls, &ph.peers[cp].id);
 
-  for (cp = 0; cp < count_p; cp++)
+    if (cp + 1 >= ph.N_peers_start)
     {
-      GNUNET_CONTAINER_multipeermap_get_multiple(ph.addresses,
-                                                 &ph.peers[cp].id,
-                                                 &do_delete_address,
-                                                 NULL);
+      /* Disable bulk to solve the problem */
+      if (GNUNET_YES == ph.bulk_running)
+      {
+        ph.expecting_solution = GNUNET_YES;
+        ph.bulk_running = GNUNET_NO;
+        ph.sf->s_bulk_stop (ph.sf->cls);
+      }
+      else
+        GNUNET_break (0);
+
+      /* Problem is solved by the solver here due to unlocking */
+      ph.expecting_solution = GNUNET_NO;
+
+      /* Update the problem */
+      if ((0 < ph.opt_update_percent) && (GNUNET_YES == ph.measure_updates))
+      {
+        /* Update */
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "Updating problem with %u peers and %u addresses\n", cp + 1,
+                    ca);
+
+        ph.expecting_solution = GNUNET_YES;
+        ph.performed_update = GNUNET_YES;
+        if (GNUNET_NO == ph.bulk_running)
+        {
+          ph.bulk_running = GNUNET_YES;
+          ph.sf->s_bulk_start (ph.sf->cls);
+        }
+        perf_update_all_addresses (cp + 1, ca, ph.opt_update_percent);
+        ph.bulk_running = GNUNET_NO;
+        ph.sf->s_bulk_stop (ph.sf->cls);
+        /* Problem is solved by the solver here due to unlocking */
+        ph.performed_update = GNUNET_NO;
+        ph.expecting_solution = GNUNET_NO;
+      }
+      GNUNET_assert (GNUNET_NO == ph.bulk_running);
     }
+  }
+  fprintf (stderr, "\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Done, cleaning up addresses\n");
   if (GNUNET_NO == ph.bulk_running)
-    {
-      ph.sf->s_bulk_stop(ph.sf->cls);
-      ph.bulk_running = GNUNET_NO;
-    }
+  {
+    ph.sf->s_bulk_start (ph.sf->cls);
+    ph.bulk_running = GNUNET_YES;
+  }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Iteration done\n");
-  GNUNET_free(ph.peers);
+  for (cp = 0; cp < count_p; cp++)
+  {
+    GNUNET_CONTAINER_multipeermap_get_multiple (ph.addresses,
+                                                &ph.peers[cp].id,
+                                                &do_delete_address,
+                                                NULL);
+  }
+  if (GNUNET_NO == ph.bulk_running)
+  {
+    ph.sf->s_bulk_stop (ph.sf->cls);
+    ph.bulk_running = GNUNET_NO;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Iteration done\n");
+  GNUNET_free (ph.peers);
 }
 
 
 static void
-run(void *cls, char * const *args, const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  GNUNET_log_setup("perf-ats-solver", "WARNING", NULL);
+  GNUNET_log_setup ("perf-ats-solver", "WARNING", NULL);
   char *sep;
-  char *src_filename = GNUNET_strdup(__FILE__);
+  char *src_filename = GNUNET_strdup (__FILE__);
   char *test_filename = cls;
   char *solver;
   char *plugin;
@@ -1226,92 +1267,98 @@ run(void *cls, char * const *args, const char *cfgfile,
   int c2;
 
   /* Extract test name */
-  if (NULL == (sep = (strstr(src_filename, ".c"))))
-    {
-      GNUNET_free(src_filename);
-      GNUNET_break(0);
-      ret = 1;
-      return;
-    }
+  if (NULL == (sep = (strstr (src_filename, ".c"))))
+  {
+    GNUNET_free (src_filename);
+    GNUNET_break (0);
+    ret = 1;
+    return;
+  }
   sep[0] = '\0';
 
-  if (NULL != (sep = strstr(test_filename, ".exe")))
+  if (NULL != (sep = strstr (test_filename, ".exe")))
     sep[0] = '\0';
 
-  if (NULL == (solver = strstr(test_filename, src_filename)))
-    {
-      GNUNET_free(src_filename);
-      GNUNET_break(0);
-      ret = 1;
-      return;
-    }
-  solver += strlen(src_filename) + 1;
-
-  if (0 == strcmp(solver, "proportional"))
-    {
-      ph.ats_string = "proportional";
-    }
-  else if (0 == strcmp(solver, "mlp"))
-    {
-      ph.ats_string = "mlp";
-    }
-  else if ((0 == strcmp(solver, "ril")))
-    {
-      ph.ats_string = "ril";
-    }
+  if (NULL == (solver = strstr (test_filename, src_filename)))
+  {
+    GNUNET_free (src_filename);
+    GNUNET_break (0);
+    ret = 1;
+    return;
+  }
+  solver += strlen (src_filename) + 1;
+
+  if (0 == strcmp (solver, "proportional"))
+  {
+    ph.ats_string = "proportional";
+  }
+  else if (0 == strcmp (solver, "mlp"))
+  {
+    ph.ats_string = "mlp";
+  }
+  else if ((0 == strcmp (solver, "ril")))
+  {
+    ph.ats_string = "ril";
+  }
   else
-    {
-      GNUNET_free(src_filename);
-      GNUNET_break(0);
-      ret = 1;
-      return;
-    }
-  GNUNET_free(src_filename);
+  {
+    GNUNET_free (src_filename);
+    GNUNET_break (0);
+    ret = 1;
+    return;
+  }
+  GNUNET_free (src_filename);
 
   /* Calculcate peers */
   if ((0 == ph.N_peers_start) && (0 == ph.N_peers_end))
-    {
-      ph.N_peers_start = DEFAULT_PEERS_START;
-      ph.N_peers_end = DEFAULT_PEERS_END;
-    }
+  {
+    ph.N_peers_start = DEFAULT_PEERS_START;
+    ph.N_peers_end = DEFAULT_PEERS_END;
+  }
   if (0 == ph.N_address)
     ph.N_address = DEFAULT_ADDRESSES;
 
 
   if (ph.N_peers_start != ph.N_peers_end)
-    fprintf(stderr, "Benchmarking solver `%s' with %u to %u peers and %u addresses in %u iterations\n",
-            ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address, ph.total_iterations);
+    fprintf (stderr,
+             "Benchmarking solver `%s' with %u to %u peers and %u addresses in %u iterations\n",
+             ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address,
+             ph.total_iterations);
   else
-    fprintf(stderr, "Benchmarking solver `%s' with %u peers and %u addresses in %u iterations\n",
-            ph.ats_string, ph.N_peers_end, ph.N_address, ph.total_iterations);
+    fprintf (stderr,
+             "Benchmarking solver `%s' with %u peers and %u addresses in %u iterations\n",
+             ph.ats_string, ph.N_peers_end, ph.N_address, ph.total_iterations);
 
   if (0 == ph.opt_update_percent)
     ph.opt_update_percent = DEFAULT_UPDATE_PERCENTAGE;
 
   /* Load quotas */
-  solver_cfg = GNUNET_CONFIGURATION_create();
-  if ((NULL == solver_cfg) || (GNUNET_SYSERR == (GNUNET_CONFIGURATION_load(solver_cfg, "perf_ats_solver.conf"))))
-    {
-      GNUNET_break(0);
-      end_now(1);
-      return;
-    }
-  if (GNUNET_NT_COUNT != load_quotas(solver_cfg,
-                                     quotas_out, quotas_in, GNUNET_NT_COUNT))
-    {
-      GNUNET_break(0);
-      end_now(1);
-      return;
-    }
+  solver_cfg = GNUNET_CONFIGURATION_create ();
+  if ((NULL == solver_cfg) || (GNUNET_SYSERR == (GNUNET_CONFIGURATION_load (
+                                                   solver_cfg,
+                                                   "perf_ats_solver.conf"))))
+  {
+    GNUNET_break (0);
+    end_now (1);
+    return;
+  }
+  if (GNUNET_NT_COUNT != load_quotas (solver_cfg,
+                                      quotas_out, quotas_in, GNUNET_NT_COUNT))
+  {
+    GNUNET_break (0);
+    end_now (1);
+    return;
+  }
 
   /* Create array of DLL to store results for iterations */
-  ph.iterations_results = GNUNET_malloc(sizeof(struct Iteration) * ph.total_iterations);
+  ph.iterations_results = GNUNET_malloc (sizeof(struct Iteration)
+                                         * ph.total_iterations);
 
   /* Load solver */
   ph.env.cfg = solver_cfg;
-  ph.stat = GNUNET_STATISTICS_create("ats", cfg);
+  ph.stat = GNUNET_STATISTICS_create ("ats", cfg);
   ph.env.stats = ph.stat;
-  ph.addresses = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_NO);
+  ph.addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
   ph.env.addresses = ph.addresses;
   ph.env.bandwidth_changed_cb = bandwidth_changed_cb;
   ph.env.get_connectivity = &get_connectivity_cb;
@@ -1320,75 +1367,77 @@ run(void *cls, char * const *args, const char *cfgfile,
   ph.env.info_cb = &solver_info_cb;
 
   for (c = 0; c < GNUNET_NT_COUNT; c++)
-    {
-      ph.env.out_quota[c] = quotas_out[c];
-      ph.env.in_quota[c] = quotas_in[c];
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 "Loading network quotas: `%s' %llu %llu \n",
-                 GNUNET_NT_to_string(c),
-                 ph.env.out_quota[c],
-                 ph.env.in_quota[c]);
-    }
-  GAS_normalization_start();
-  GAS_preference_init();
-
-  GNUNET_asprintf(&plugin,
-                  "libgnunet_plugin_ats_%s",
-                  ph.ats_string);
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("Initializing solver `%s'\n"),
-             ph.ats_string);
-  if (NULL == (ph.sf = GNUNET_PLUGIN_load(plugin, &ph.env)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to initialize solver `%s'!\n"),
-                 plugin);
-      ret = 1;
-      return;
-    }
+  {
+    ph.env.out_quota[c] = quotas_out[c];
+    ph.env.in_quota[c] = quotas_in[c];
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Loading network quotas: `%s' %llu %llu \n",
+                GNUNET_NT_to_string (c),
+                ph.env.out_quota[c],
+                ph.env.in_quota[c]);
+  }
+  GAS_normalization_start ();
+  GAS_preference_init ();
+
+  GNUNET_asprintf (&plugin,
+                   "libgnunet_plugin_ats_%s",
+                   ph.ats_string);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Initializing solver `%s'\n"),
+              ph.ats_string);
+  if (NULL == (ph.sf = GNUNET_PLUGIN_load (plugin, &ph.env)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to initialize solver `%s'!\n"),
+                plugin);
+    ret = 1;
+    return;
+  }
 
   /* Do the benchmark */
-  for (ph.current_iteration = 1; ph.current_iteration <= ph.total_iterations; ph.current_iteration++)
-    {
-      fprintf(stderr,
-              "Iteration %u of %u starting\n",
-              ph.current_iteration,
-              ph.total_iterations);
-      perf_run_iteration();
-      evaluate(ph.current_iteration);
-      fprintf(stderr,
-              "Iteration %u of %u done\n",
-              ph.current_iteration,
-              ph.total_iterations);
-    }
+  for (ph.current_iteration = 1; ph.current_iteration <= ph.total_iterations;
+       ph.current_iteration++)
+  {
+    fprintf (stderr,
+             "Iteration %u of %u starting\n",
+             ph.current_iteration,
+             ph.total_iterations);
+    perf_run_iteration ();
+    evaluate (ph.current_iteration);
+    fprintf (stderr,
+             "Iteration %u of %u done\n",
+             ph.current_iteration,
+             ph.total_iterations);
+  }
   if (ph.create_datafile)
-    write_all_iterations();
+    write_all_iterations ();
 
   /* Unload solver*/
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("Unloading solver `%s'\n"),
-             ph.ats_string);
-  GNUNET_PLUGIN_unload(plugin, ph.sf);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Unloading solver `%s'\n"),
+              ph.ats_string);
+  GNUNET_PLUGIN_unload (plugin, ph.sf);
   ph.sf = NULL;
-  GNUNET_free(plugin);
+  GNUNET_free (plugin);
   for (c = 0; c < ph.total_iterations; c++)
+  {
+    for (c2 = ph.N_peers_start; c2 < ph.N_peers_end; c2++)
     {
-      for (c2 = ph.N_peers_start; c2 < ph.N_peers_end; c2++)
-        {
-          if (0 == c2)
-            continue;
-          if (ph.measure_updates)
-            GNUNET_free_non_null(ph.iterations_results[c].update_results_array[c2]);
-          GNUNET_free(ph.iterations_results[c].results_array[c2]);
-        }
+      if (0 == c2)
+        continue;
       if (ph.measure_updates)
-        GNUNET_free(ph.iterations_results[c].update_results_array);
-      GNUNET_free(ph.iterations_results[c].results_array);
+        GNUNET_free_non_null (
+          ph.iterations_results[c].update_results_array[c2]);
+      GNUNET_free (ph.iterations_results[c].results_array[c2]);
     }
-  GNUNET_free(ph.iterations_results);
-
-  GNUNET_CONFIGURATION_destroy(solver_cfg);
-  GNUNET_STATISTICS_destroy(ph.stat, GNUNET_NO);
+    if (ph.measure_updates)
+      GNUNET_free (ph.iterations_results[c].update_results_array);
+    GNUNET_free (ph.iterations_results[c].results_array);
+  }
+  GNUNET_free (ph.iterations_results);
+
+  GNUNET_CONFIGURATION_destroy (solver_cfg);
+  GNUNET_STATISTICS_destroy (ph.stat, GNUNET_NO);
 }
 
 
@@ -1399,7 +1448,7 @@ run(void *cls, char * const *args, const char *cfgfile,
  * @param argv argument values
  */
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   /* extract command line arguments */
   ph.opt_update_percent = 0;
@@ -1412,45 +1461,47 @@ main(int argc, char *argv[])
   ph.total_iterations = 1;
 
   static struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_uint('a',
-                              "addresses",
-                              gettext_noop("addresses to use"),
-                              &ph.N_address),
-
-    GNUNET_GETOPT_option_uint('s',
-                              "start",
-                              gettext_noop("start with peer"),
-                              &ph.N_peers_start),
-
-    GNUNET_GETOPT_option_uint('e',
-                              "end",
-                              gettext_noop("end with peer"),
-                              &ph.N_peers_end),
-
-    GNUNET_GETOPT_option_uint('i',
-                              "iterations",
-                              gettext_noop("number of iterations used for averaging (default: 1)"),
-                              &ph.total_iterations),
-
-    GNUNET_GETOPT_option_uint('p',
-                              "percentage",
-                              gettext_noop("update a fix percentage of addresses"),
-                              &ph.opt_update_percent),
-
-    GNUNET_GETOPT_option_flag('d',
-                              "data",
-                              gettext_noop("create data file"),
-                              &ph.create_datafile),
-
-    GNUNET_GETOPT_option_flag('u',
-                              "update",
-                              gettext_noop("measure updates"),
-                              &ph.measure_updates),
+    GNUNET_GETOPT_option_uint ('a',
+                               "addresses",
+                               gettext_noop ("addresses to use"),
+                               &ph.N_address),
+
+    GNUNET_GETOPT_option_uint ('s',
+                               "start",
+                               gettext_noop ("start with peer"),
+                               &ph.N_peers_start),
+
+    GNUNET_GETOPT_option_uint ('e',
+                               "end",
+                               gettext_noop ("end with peer"),
+                               &ph.N_peers_end),
+
+    GNUNET_GETOPT_option_uint ('i',
+                               "iterations",
+                               gettext_noop (
+                                 "number of iterations used for averaging (default: 1)"),
+                               &ph.total_iterations),
+
+    GNUNET_GETOPT_option_uint ('p',
+                               "percentage",
+                               gettext_noop (
+                                 "update a fix percentage of addresses"),
+                               &ph.opt_update_percent),
+
+    GNUNET_GETOPT_option_flag ('d',
+                               "data",
+                               gettext_noop ("create data file"),
+                               &ph.create_datafile),
+
+    GNUNET_GETOPT_option_flag ('u',
+                               "update",
+                               gettext_noop ("measure updates"),
+                               &ph.measure_updates),
 
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_PROGRAM_run(argc, argv, argv[0], NULL, options, &run, argv[0]);
+  GNUNET_PROGRAM_run (argc, argv, argv[0], NULL, options, &run, argv[0]);
   return ret;
 }
 
diff --git a/src/ats/plugin_ats2_common.c b/src/ats/plugin_ats2_common.c
index c12d2a06f..da20a342c 100644
--- a/src/ats/plugin_ats2_common.c
+++ b/src/ats/plugin_ats2_common.c
@@ -40,59 +40,60 @@
  * @param quota[out] set to quota, #DEFAULT_BANDWIDTH if @a cfg does not say anything useful
  */
 static void
-get_quota(const struct GNUNET_CONFIGURATION_Handle *cfg,
-          const char *nts,
-          const char *direction,
-          unsigned long long *quota)
+get_quota (const struct GNUNET_CONFIGURATION_Handle *cfg,
+           const char *nts,
+           const char *direction,
+           unsigned long long *quota)
 {
   char *quota_str;
   char *quota_s;
   int res;
 
-  GNUNET_asprintf(&quota_s,
-                  "%s_QUOTA_%s",
-                  nts,
-                  direction);
+  GNUNET_asprintf (&quota_s,
+                   "%s_QUOTA_%s",
+                   nts,
+                   direction);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(cfg,
-                                            "ATS",
-                                            quota_s,
-                                            &quota_str))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING,
-                                "ATS",
-                                quota_s);
-      GNUNET_free(quota_s);
-      return;
-    }
-  GNUNET_free(quota_s);
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "ATS",
+                                             quota_s,
+                                             &quota_str))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+                               "ATS",
+                               quota_s);
+    GNUNET_free (quota_s);
+    return;
+  }
+  GNUNET_free (quota_s);
   res = GNUNET_NO;
-  if (0 == strcmp(quota_str,
-                  "unlimited"))
-    {
-      *quota = ULONG_MAX;
-      res = GNUNET_YES;
-    }
+  if (0 == strcmp (quota_str,
+                   "unlimited"))
+  {
+    *quota = ULONG_MAX;
+    res = GNUNET_YES;
+  }
   if ((GNUNET_NO == res) &&
       (GNUNET_OK ==
-       GNUNET_STRINGS_fancy_size_to_bytes(quota_str,
-                                          quota)))
+       GNUNET_STRINGS_fancy_size_to_bytes (quota_str,
+                                           quota)))
     res = GNUNET_YES;
   if ((GNUNET_NO == res) &&
       (1 ==
-       sscanf(quota_str,
-              "%llu",
-              quota)))
+       sscanf (quota_str,
+               "%llu",
+               quota)))
     res = GNUNET_YES;
   if (GNUNET_NO == res)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Could not load %s quota for network `%s': `%s', assigning default bandwidth %llu\n"),
-                 direction,
-                 nts,
-                 quota_str,
-                 (unsigned long long)DEFAULT_BANDWIDTH);
-      *quota = DEFAULT_BANDWIDTH;
-    }
-  GNUNET_free(quota_str);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ (
+                  "Could not load %s quota for network `%s': `%s', assigning default bandwidth %llu\n"),
+                direction,
+                nts,
+                quota_str,
+                (unsigned long long) DEFAULT_BANDWIDTH);
+    *quota = DEFAULT_BANDWIDTH;
+  }
+  GNUNET_free (quota_str);
 }
diff --git a/src/ats/plugin_ats2_simple.c b/src/ats/plugin_ats2_simple.c
index 90566c561..3062b6019 100644
--- a/src/ats/plugin_ats2_simple.c
+++ b/src/ats/plugin_ats2_simple.c
@@ -31,7 +31,7 @@
 #include "gnunet_hello_lib.h"
 #include "gnunet_peerstore_service.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-simple", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-simple", __VA_ARGS__)
 
 
 /**
@@ -68,7 +68,8 @@ struct Peer;
 /**
  * Entry in list of addresses we could try per peer.
  */
-struct Hello {
+struct Hello
+{
   /**
    * Kept in a DLL.
    */
@@ -121,7 +122,8 @@ struct Hello {
  * Internal representation of a session by the plugin.
  * (If desired, plugin may just use NULL.)
  */
-struct GNUNET_ATS_SessionHandle {
+struct GNUNET_ATS_SessionHandle
+{
   /**
    * Kept in DLL per peer.
    */
@@ -189,7 +191,8 @@ struct GNUNET_ATS_SessionHandle {
  * Information about preferences and sessions we track
  * per peer.
  */
-struct Peer {
+struct Peer
+{
   /**
    * Kept in DLL per peer.
    */
@@ -247,7 +250,8 @@ struct Peer {
 /**
  * Representation of a network (to be expanded...)
  */
-struct Network {
+struct Network
+{
   /**
    * Total inbound quota
    */
@@ -268,7 +272,8 @@ struct Network {
 /**
  * A handle for the proportional solver
  */
-struct SimpleHandle {
+struct SimpleHandle
+{
   /**
    * Our execution environment.
    */
@@ -306,9 +311,9 @@ struct SimpleHandle {
  * @return NULL for not found
  */
 struct Peer *
-lookup_peer(struct SimpleHandle *h, const struct GNUNET_PeerIdentity *pid)
+lookup_peer (struct SimpleHandle *h, const struct GNUNET_PeerIdentity *pid)
 {
-  return GNUNET_CONTAINER_multipeermap_get(h->peers, pid);
+  return GNUNET_CONTAINER_multipeermap_get (h->peers, pid);
 }
 
 
@@ -320,7 +325,7 @@ lookup_peer(struct SimpleHandle *h, const struct GNUNET_PeerIdentity *pid)
  * @return #GNUNET_YES if no information is left in @a p
  */
 static int
-peer_test_dead(struct Peer *p)
+peer_test_dead (struct Peer *p)
 {
   for (enum GNUNET_MQ_PreferenceKind pk = 0; pk < GNUNET_MQ_PREFERENCE_COUNT;
        pk++)
@@ -340,17 +345,17 @@ peer_test_dead(struct Peer *p)
  * @param hello[in,out] address suggestion to make
  */
 static void
-suggest_hello(struct Hello *hello)
+suggest_hello (struct Hello *hello)
 {
   struct Peer *p = hello->peer;
   struct SimpleHandle *h = p->h;
 
-  p->last_suggestion = hello->last_attempt = GNUNET_TIME_absolute_get();
+  p->last_suggestion = hello->last_attempt = GNUNET_TIME_absolute_get ();
   hello->backoff =
-    GNUNET_TIME_randomized_backoff(hello->backoff,
-                                   GNUNET_TIME_absolute_get_remaining(
-                                     hello->expiration));
-  h->env->suggest_cb(h->env->cls, &p->pid, hello->address);
+    GNUNET_TIME_randomized_backoff (hello->backoff,
+                                    GNUNET_TIME_absolute_get_remaining (
+                                      hello->expiration));
+  h->env->suggest_cb (h->env->cls, &p->pid, hello->address);
 }
 
 
@@ -369,7 +374,7 @@ suggest_hello(struct Hello *hello)
  * @param cls a `struct Peer`
  */
 static void
-suggest_start_cb(void *cls)
+suggest_start_cb (void *cls)
 {
   struct Peer *p = cls;
   struct GNUNET_TIME_Relative delay = GNUNET_TIME_UNIT_ZERO;
@@ -387,63 +392,63 @@ suggest_start_cb(void *cls)
   /* calculate square of number of sessions */
   num_sessions++; /* start with 1, even if we have zero sessions */
   if (num_sessions < UINT16_MAX)
-    sq = num_sessions * (uint32_t)num_sessions;
+    sq = num_sessions * (uint32_t) num_sessions;
   else
     sq = UINT32_MAX;
   xdelay =
-    GNUNET_TIME_randomized_backoff(GNUNET_TIME_relative_multiply(SUGGEST_FREQ,
-                                                                 sq),
-                                   GNUNET_TIME_UNIT_FOREVER_REL);
-  xnext = GNUNET_TIME_relative_to_absolute(xdelay);
+    GNUNET_TIME_randomized_backoff (GNUNET_TIME_relative_multiply (SUGGEST_FREQ,
+                                                                   sq),
+                                    GNUNET_TIME_UNIT_FOREVER_REL);
+  xnext = GNUNET_TIME_relative_to_absolute (xdelay);
 
   p->task = NULL;
   while (0 == delay.rel_value_us)
+  {
+    struct Hello *next;
+    struct GNUNET_TIME_Absolute xmax;
+
+    if (NULL != hello)
     {
-      struct Hello *next;
-      struct GNUNET_TIME_Absolute xmax;
-
-      if (NULL != hello)
-        {
-          /* We went through the loop already once and found
-             a HELLO that is due *now*, so make a suggestion! */
-          GNUNET_break(NULL == hello->sh);
-          suggest_hello(hello);
-          hello = NULL;
-          hpt = GNUNET_TIME_UNIT_FOREVER_ABS;
-        }
-      for (struct Hello *pos = p->h_head; NULL != pos; pos = next)
-        {
-          struct GNUNET_TIME_Absolute pt;
-
-          next = pos->next;
-          if (NULL != pos->sh)
-            continue;
-          if (0 ==
-              GNUNET_TIME_absolute_get_remaining(pos->expiration).rel_value_us)
-            {
-              /* expired, remove! */
-              GNUNET_CONTAINER_DLL_remove(p->h_head, p->h_tail, pos);
-              GNUNET_free(pos);
-              continue;
-            }
-          pt = GNUNET_TIME_absolute_add(pos->last_attempt, pos->backoff);
-          if ((NULL == hello) || (pt.abs_value_us < hpt.abs_value_us))
-            {
-              hello = pos;
-              hpt = pt;
-            }
-        }
-      if (NULL == hello)
-        return; /* no HELLOs that could still be tried */
-
-      /* hpt is now the *earliest* possible time for any HELLO
-         but we might not want to go for as early as possible for
-         this peer. So the actual time is the max of the earliest
-         HELLO and the 'xnext' */
-      xmax = GNUNET_TIME_absolute_max(hpt, xnext);
-      delay = GNUNET_TIME_absolute_get_remaining(xmax);
+      /* We went through the loop already once and found
+         a HELLO that is due *now*, so make a suggestion! */
+      GNUNET_break (NULL == hello->sh);
+      suggest_hello (hello);
+      hello = NULL;
+      hpt = GNUNET_TIME_UNIT_FOREVER_ABS;
     }
-  p->task = GNUNET_SCHEDULER_add_delayed(delay, &suggest_start_cb, p);
+    for (struct Hello *pos = p->h_head; NULL != pos; pos = next)
+    {
+      struct GNUNET_TIME_Absolute pt;
+
+      next = pos->next;
+      if (NULL != pos->sh)
+        continue;
+      if (0 ==
+          GNUNET_TIME_absolute_get_remaining (pos->expiration).rel_value_us)
+      {
+        /* expired, remove! */
+        GNUNET_CONTAINER_DLL_remove (p->h_head, p->h_tail, pos);
+        GNUNET_free (pos);
+        continue;
+      }
+      pt = GNUNET_TIME_absolute_add (pos->last_attempt, pos->backoff);
+      if ((NULL == hello) || (pt.abs_value_us < hpt.abs_value_us))
+      {
+        hello = pos;
+        hpt = pt;
+      }
+    }
+    if (NULL == hello)
+      return;   /* no HELLOs that could still be tried */
+
+    /* hpt is now the *earliest* possible time for any HELLO
+       but we might not want to go for as early as possible for
+       this peer. So the actual time is the max of the earliest
+       HELLO and the 'xnext' */
+    xmax = GNUNET_TIME_absolute_max (hpt, xnext);
+    delay = GNUNET_TIME_absolute_get_remaining (xmax);
+  }
+  p->task = GNUNET_SCHEDULER_add_delayed (delay, &suggest_start_cb, p);
 }
 
 
@@ -455,9 +460,9 @@ suggest_start_cb(void *cls)
  * @param emsg error message, or NULL if no errors
  */
 static void
-watch_cb(void *cls,
-         const struct GNUNET_PEERSTORE_Record *record,
-         const char *emsg)
+watch_cb (void *cls,
+          const struct GNUNET_PEERSTORE_Record *record,
+          const char *emsg)
 {
   struct Peer *p = cls;
   char *addr;
@@ -466,65 +471,65 @@ watch_cb(void *cls,
   struct GNUNET_TIME_Absolute expiration;
   struct Hello *hello;
 
-  if (0 != GNUNET_memcmp(&p->pid, &record->peer))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  if (0 != strcmp(record->key, GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  addr = GNUNET_HELLO_extract_address(record->value,
-                                      record->value_size,
-                                      &p->pid,
-                                      &nt,
-                                      &expiration);
+  if (0 != GNUNET_memcmp (&p->pid, &record->peer))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  if (0 != strcmp (record->key, GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  addr = GNUNET_HELLO_extract_address (record->value,
+                                       record->value_size,
+                                       &p->pid,
+                                       &nt,
+                                       &expiration);
   if (NULL == addr)
     return; /* invalid hello, bad signature, other problem */
-  if (0 == GNUNET_TIME_absolute_get_remaining(expiration).rel_value_us)
-    {
-      /* expired, ignore */
-      GNUNET_free(addr);
-      return;
-    }
+  if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
+  {
+    /* expired, ignore */
+    GNUNET_free (addr);
+    return;
+  }
   /* check if addr is already known */
   for (struct Hello *he = p->h_head; NULL != he; he = he->next)
+  {
+    if (0 != strcmp (he->address, addr))
+      continue;
+    if (he->expiration.abs_value_us < expiration.abs_value_us)
     {
-      if (0 != strcmp(he->address, addr))
-        continue;
-      if (he->expiration.abs_value_us < expiration.abs_value_us)
-        {
-          he->expiration = expiration;
-          he->nt = nt;
-        }
-      GNUNET_free(addr);
-      return;
+      he->expiration = expiration;
+      he->nt = nt;
     }
+    GNUNET_free (addr);
+    return;
+  }
   /* create new HELLO */
-  alen = strlen(addr) + 1;
-  hello = GNUNET_malloc(sizeof(struct Hello) + alen);
-  hello->address = (const char *)&hello[1];
+  alen = strlen (addr) + 1;
+  hello = GNUNET_malloc (sizeof(struct Hello) + alen);
+  hello->address = (const char *) &hello[1];
   hello->expiration = expiration;
   hello->nt = nt;
   hello->peer = p;
-  memcpy(&hello[1], addr, alen);
-  GNUNET_CONTAINER_DLL_insert(p->h_head, p->h_tail, hello);
+  memcpy (&hello[1], addr, alen);
+  GNUNET_CONTAINER_DLL_insert (p->h_head, p->h_tail, hello);
   /* check if sh for this HELLO already exists */
   for (struct GNUNET_ATS_SessionHandle *sh = p->sh_head; NULL != sh;
        sh = sh->next)
-    {
-      if ((NULL == sh->address) || (0 != strcmp(sh->address, addr)))
-        continue;
-      GNUNET_assert(NULL == sh->hello);
-      sh->hello = hello;
-      hello->sh = sh;
-      break;
-    }
-  GNUNET_free(addr);
+  {
+    if ((NULL == sh->address) || (0 != strcmp (sh->address, addr)))
+      continue;
+    GNUNET_assert (NULL == sh->hello);
+    sh->hello = hello;
+    hello->sh = sh;
+    break;
+  }
+  GNUNET_free (addr);
   if (NULL == p->task)
-    p->task = GNUNET_SCHEDULER_add_now(&suggest_start_cb, p);
+    p->task = GNUNET_SCHEDULER_add_now (&suggest_start_cb, p);
 }
 
 
@@ -536,27 +541,27 @@ watch_cb(void *cls,
  * @return a peer handle
  */
 static struct Peer *
-peer_add(struct SimpleHandle *h, const struct GNUNET_PeerIdentity *pid)
+peer_add (struct SimpleHandle *h, const struct GNUNET_PeerIdentity *pid)
 {
-  struct Peer *p = lookup_peer(h, pid);
+  struct Peer *p = lookup_peer (h, pid);
 
   if (NULL != p)
     return p;
-  p = GNUNET_new(struct Peer);
+  p = GNUNET_new (struct Peer);
   p->h = h;
   p->pid = *pid;
-  p->wc = GNUNET_PEERSTORE_watch(h->ps,
-                                 "transport",
-                                 &p->pid,
-                                 GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY,
-                                 &watch_cb,
-                                 p);
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_put(
-                  h->peers,
-                  &p->pid,
-                  p,
-                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  p->wc = GNUNET_PEERSTORE_watch (h->ps,
+                                  "transport",
+                                  &p->pid,
+                                  GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY,
+                                  &watch_cb,
+                                  p);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_put (
+                   h->peers,
+                   &p->pid,
+                   p,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
   return p;
 }
@@ -569,31 +574,31 @@ peer_add(struct SimpleHandle *h, const struct GNUNET_PeerIdentity *pid)
  * @param p the peer to free
  */
 static void
-peer_free(struct Peer *p)
+peer_free (struct Peer *p)
 {
   struct SimpleHandle *h = p->h;
   struct Hello *hello;
 
-  GNUNET_assert(NULL == p->sh_head);
+  GNUNET_assert (NULL == p->sh_head);
   while (NULL != (hello = p->h_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(p->h_head, p->h_tail, hello);
-      GNUNET_assert(NULL == hello->sh);
-      GNUNET_free(hello);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (p->h_head, p->h_tail, hello);
+    GNUNET_assert (NULL == hello->sh);
+    GNUNET_free (hello);
+  }
   if (NULL != p->task)
-    {
-      GNUNET_SCHEDULER_cancel(p->task);
-      p->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (p->task);
+    p->task = NULL;
+  }
   if (NULL != p->wc)
-    {
-      GNUNET_PEERSTORE_watch_cancel(p->wc);
-      p->wc = NULL;
-    }
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(h->peers, &p->pid, p));
-  GNUNET_free(p);
+  {
+    GNUNET_PEERSTORE_watch_cancel (p->wc);
+    p->wc = NULL;
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (h->peers, &p->pid, p));
+  GNUNET_free (p);
 }
 
 
@@ -604,7 +609,7 @@ peer_free(struct Peer *p)
  * @param sh session handle to consider updating transport for
  */
 static void
-consider_notify_transport(struct GNUNET_ATS_SessionHandle *sh)
+consider_notify_transport (struct GNUNET_ATS_SessionHandle *sh)
 {
   struct Peer *peer = sh->peer;
   struct SimpleHandle *h = peer->h;
@@ -615,15 +620,15 @@ consider_notify_transport(struct GNUNET_ATS_SessionHandle *sh)
   int64_t delta_in;
   int64_t delta_out;
 
-  delay = GNUNET_TIME_absolute_get_duration(sh->last_allocation);
+  delay = GNUNET_TIME_absolute_get_duration (sh->last_allocation);
   /* A significant change is more than 10% of the quota,
      which is given in bytes/second */
-  sig_in = h->networks[nt].total_quota_in * (delay.rel_value_us / 1000LL) /
-           1000LL / 10;
-  sig_out = h->networks[nt].total_quota_out * (delay.rel_value_us / 1000LL) /
-            1000LL / 10;
-  delta_in = ((int64_t)ntohl(sh->bw_in.value__)) - ((int64_t)sh->target_in);
-  delta_out = ((int64_t)ntohl(sh->bw_in.value__)) - ((int64_t)sh->target_in);
+  sig_in = h->networks[nt].total_quota_in * (delay.rel_value_us / 1000LL)
+           / 1000LL / 10;
+  sig_out = h->networks[nt].total_quota_out * (delay.rel_value_us / 1000LL)
+            / 1000LL / 10;
+  delta_in = ((int64_t) ntohl (sh->bw_in.value__)) - ((int64_t) sh->target_in);
+  delta_out = ((int64_t) ntohl (sh->bw_in.value__)) - ((int64_t) sh->target_in);
   /* we want the absolute values */
   if (delta_in < 0)
     delta_in = -delta_in;
@@ -638,23 +643,24 @@ consider_notify_transport(struct GNUNET_ATS_SessionHandle *sh)
   /* change is significant, tell transport! */
   if (sh->target_in > UINT32_MAX)
     sh->target_in = UINT32_MAX;
-  sh->bw_in.value__ = htonl((uint32_t)sh->target_in);
+  sh->bw_in.value__ = htonl ((uint32_t) sh->target_in);
   if (sh->target_out > UINT32_MAX)
     sh->target_out = UINT32_MAX;
-  sh->bw_out.value__ = htonl((uint32_t)sh->target_out);
-  sh->last_allocation = GNUNET_TIME_absolute_get();
-  h->env->allocate_cb(h->env->cls,
-                      sh->session,
-                      &peer->pid,
-                      sh->bw_in,
-                      sh->bw_out);
+  sh->bw_out.value__ = htonl ((uint32_t) sh->target_out);
+  sh->last_allocation = GNUNET_TIME_absolute_get ();
+  h->env->allocate_cb (h->env->cls,
+                       sh->session,
+                       &peer->pid,
+                       sh->bw_in,
+                       sh->bw_out);
 }
 
 
 /**
  * Closure for #update_counters and #update_allocation.
  */
-struct Counters {
+struct Counters
+{
   /**
    * Plugin's state.
    */
@@ -698,103 +704,103 @@ struct Counters {
  * @return #GNUNET_YES (continue to iterate)
  */
 static int
-update_counters(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
+update_counters (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 {
   struct Counters *c = cls;
   struct Peer *peer = value;
   struct GNUNET_ATS_SessionHandle *best[GNUNET_MQ_PREFERENCE_COUNT];
 
-  (void)pid;
+  (void) pid;
   if (NULL == peer->sh_head)
     return GNUNET_YES; /* no available session, cannot allocate bandwidth */
-  memset(best, 0, sizeof(best));
+  memset (best, 0, sizeof(best));
   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head; NULL != sh;
        sh = sh->next)
+  {
+    enum GNUNET_NetworkType nt = sh->data->prop.nt;
+
+    sh->target_out = MIN_BANDWIDTH_PER_SESSION;
+    c->bw_out_by_nt[nt] += MIN_BANDWIDTH_PER_SESSION;
+    c->bw_in_by_nt[nt] +=
+      GNUNET_MAX (MIN_BANDWIDTH_PER_SESSION, sh->data->prop.goodput_in);
+    for (enum GNUNET_MQ_PreferenceKind pk = 0; pk < GNUNET_MQ_PREFERENCE_COUNT;
+         pk++)
     {
-      enum GNUNET_NetworkType nt = sh->data->prop.nt;
-
-      sh->target_out = MIN_BANDWIDTH_PER_SESSION;
-      c->bw_out_by_nt[nt] += MIN_BANDWIDTH_PER_SESSION;
-      c->bw_in_by_nt[nt] +=
-        GNUNET_MAX(MIN_BANDWIDTH_PER_SESSION, sh->data->prop.goodput_in);
-      for (enum GNUNET_MQ_PreferenceKind pk = 0; pk < GNUNET_MQ_PREFERENCE_COUNT;
-           pk++)
-        {
-          /* General rule: always prefer smaller distance if possible,
-             otherwise decide by pk: */
-          switch (pk)
-            {
-            case GNUNET_MQ_PREFERENCE_NONE:
-              break;
-
-            case GNUNET_MQ_PREFERENCE_BANDWIDTH:
-              /* For bandwidth, we compare the sum of transmitted bytes and
-                 confirmed transmitted bytes, so confirmed data counts twice */
-              if ((NULL == best[pk]) ||
-                  (sh->data->prop.distance < best[pk]->data->prop.distance) ||
-                  (sh->data->prop.utilization_out + sh->data->prop.goodput_out >
-                   best[pk]->data->prop.utilization_out +
-                   best[pk]->data->prop.goodput_out))
-                best[pk] = sh;
-              /* If both are equal (i.e. usually this happens if there is a zero), use
-                 latency as a yardstick */
-              if ((sh->data->prop.utilization_out + sh->data->prop.goodput_out ==
-                   best[pk]->data->prop.utilization_out +
-                   best[pk]->data->prop.goodput_out) &&
-                  (sh->data->prop.distance == best[pk]->data->prop.distance) &&
-                  (sh->data->prop.delay.rel_value_us <
-                   best[pk]->data->prop.delay.rel_value_us))
-                best[pk] = sh;
-              break;
-
-            case GNUNET_MQ_PREFERENCE_LATENCY:
-              if ((NULL == best[pk]) ||
-                  (sh->data->prop.distance < best[pk]->data->prop.distance) ||
-                  ((sh->data->prop.distance == best[pk]->data->prop.distance) &&
-                   (sh->data->prop.delay.rel_value_us <
-                    best[pk]->data->prop.delay.rel_value_us)))
-                best[pk] = sh;
-              break;
-
-            case GNUNET_MQ_PREFERENCE_RELIABILITY:
-              /* For reliability, we consider the ratio of goodput to utilization
-                 (but use multiplicative formultations to avoid division by zero) */
-              if ((NULL == best[pk]) || (1ULL * sh->data->prop.goodput_out *
-                                         best[pk]->data->prop.utilization_out >
-                                         1ULL * sh->data->prop.utilization_out *
-                                         best[pk]->data->prop.goodput_out))
-                best[pk] = sh;
-              /* If both are equal (i.e. usually this happens if there is a zero), use
-                 latency as a yardstick */
-              if ((1ULL * sh->data->prop.goodput_out *
-                   best[pk]->data->prop.utilization_out ==
-                   1ULL * sh->data->prop.utilization_out *
-                   best[pk]->data->prop.goodput_out) &&
-                  (sh->data->prop.distance == best[pk]->data->prop.distance) &&
-                  (sh->data->prop.delay.rel_value_us <
-                   best[pk]->data->prop.delay.rel_value_us))
-                best[pk] = sh;
-              break;
-            }
-        }
+      /* General rule: always prefer smaller distance if possible,
+         otherwise decide by pk: */
+      switch (pk)
+      {
+      case GNUNET_MQ_PREFERENCE_NONE:
+        break;
+
+      case GNUNET_MQ_PREFERENCE_BANDWIDTH:
+        /* For bandwidth, we compare the sum of transmitted bytes and
+           confirmed transmitted bytes, so confirmed data counts twice */
+        if ((NULL == best[pk]) ||
+            (sh->data->prop.distance < best[pk]->data->prop.distance) ||
+            (sh->data->prop.utilization_out + sh->data->prop.goodput_out >
+             best[pk]->data->prop.utilization_out
+             + best[pk]->data->prop.goodput_out))
+          best[pk] = sh;
+        /* If both are equal (i.e. usually this happens if there is a zero), use
+           latency as a yardstick */
+        if ((sh->data->prop.utilization_out + sh->data->prop.goodput_out ==
+             best[pk]->data->prop.utilization_out
+             + best[pk]->data->prop.goodput_out) &&
+            (sh->data->prop.distance == best[pk]->data->prop.distance) &&
+            (sh->data->prop.delay.rel_value_us <
+             best[pk]->data->prop.delay.rel_value_us))
+          best[pk] = sh;
+        break;
+
+      case GNUNET_MQ_PREFERENCE_LATENCY:
+        if ((NULL == best[pk]) ||
+            (sh->data->prop.distance < best[pk]->data->prop.distance) ||
+            ((sh->data->prop.distance == best[pk]->data->prop.distance) &&
+             (sh->data->prop.delay.rel_value_us <
+              best[pk]->data->prop.delay.rel_value_us)))
+          best[pk] = sh;
+        break;
+
+      case GNUNET_MQ_PREFERENCE_RELIABILITY:
+        /* For reliability, we consider the ratio of goodput to utilization
+           (but use multiplicative formultations to avoid division by zero) */
+        if ((NULL == best[pk]) || (1ULL * sh->data->prop.goodput_out
+                                   * best[pk]->data->prop.utilization_out >
+                                   1ULL * sh->data->prop.utilization_out
+                                   * best[pk]->data->prop.goodput_out))
+          best[pk] = sh;
+        /* If both are equal (i.e. usually this happens if there is a zero), use
+           latency as a yardstick */
+        if ((1ULL * sh->data->prop.goodput_out
+             * best[pk]->data->prop.utilization_out ==
+             1ULL * sh->data->prop.utilization_out
+             * best[pk]->data->prop.goodput_out) &&
+            (sh->data->prop.distance == best[pk]->data->prop.distance) &&
+            (sh->data->prop.delay.rel_value_us <
+             best[pk]->data->prop.delay.rel_value_us))
+          best[pk] = sh;
+        break;
+      }
     }
+  }
   /* for first round, assign target bandwidth simply to sum of
      requested bandwidth */
   for (enum GNUNET_MQ_PreferenceKind pk =
          1 /* skip GNUNET_MQ_PREFERENCE_NONE */;
        pk < GNUNET_MQ_PREFERENCE_COUNT;
        pk++)
-    {
-      const struct GNUNET_ATS_SessionData *data = best[pk]->data;
-      enum GNUNET_NetworkType nt;
-
-      GNUNET_assert(NULL != data);
-      nt = data->prop.nt;
-      best[pk]->target_out =
-        GNUNET_MIN(peer->bw_by_pk[pk], MIN_BANDWIDTH_PER_SESSION);
-      c->bw_out_by_nt[nt] +=
-        (uint64_t)(best[pk]->target_out - MIN_BANDWIDTH_PER_SESSION);
-    }
+  {
+    const struct GNUNET_ATS_SessionData *data = best[pk]->data;
+    enum GNUNET_NetworkType nt;
+
+    GNUNET_assert (NULL != data);
+    nt = data->prop.nt;
+    best[pk]->target_out =
+      GNUNET_MIN (peer->bw_by_pk[pk], MIN_BANDWIDTH_PER_SESSION);
+    c->bw_out_by_nt[nt] +=
+      (uint64_t) (best[pk]->target_out - MIN_BANDWIDTH_PER_SESSION);
+  }
   return GNUNET_YES;
 }
 
@@ -809,23 +815,23 @@ update_counters(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
  * @return #GNUNET_YES (continue to iterate)
  */
 static int
-update_allocation(void *cls,
-                  const struct GNUNET_PeerIdentity *pid,
-                  void *value)
+update_allocation (void *cls,
+                   const struct GNUNET_PeerIdentity *pid,
+                   void *value)
 {
   struct Counters *c = cls;
   struct Peer *peer = value;
 
-  (void)pid;
+  (void) pid;
   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head; NULL != sh;
        sh = sh->next)
-    {
-      enum GNUNET_NetworkType nt = sh->data->prop.nt;
+  {
+    enum GNUNET_NetworkType nt = sh->data->prop.nt;
 
-      sh->target_out = (uint64_t)(c->scale_out[nt] * sh->target_out);
-      sh->target_in = (uint64_t)(c->scale_in[nt] * sh->target_in);
-      consider_notify_transport(sh);
-    }
+    sh->target_out = (uint64_t) (c->scale_out[nt] * sh->target_out);
+    sh->target_in = (uint64_t) (c->scale_in[nt] * sh->target_in);
+    consider_notify_transport (sh);
+  }
   return GNUNET_YES;
 }
 
@@ -834,23 +840,23 @@ update_allocation(void *cls,
  * The world changed, recalculate our allocations.
  */
 static void
-update(struct SimpleHandle *h)
+update (struct SimpleHandle *h)
 {
   struct Counters cnt = { .h = h };
 
-  GNUNET_CONTAINER_multipeermap_iterate(h->peers, &update_counters, &cnt);
+  GNUNET_CONTAINER_multipeermap_iterate (h->peers, &update_counters, &cnt);
   /* calculate how badly the missmatch between requested
      allocations and available bandwidth is per network type */
   for (enum GNUNET_NetworkType nt = 0; nt < GNUNET_NT_COUNT; nt++)
-    {
-      cnt.scale_out[nt] =
-        1.0 * cnt.bw_out_by_nt[nt] / h->networks[nt].total_quota_out;
-      cnt.scale_in[nt] =
-        1.0 * cnt.bw_in_by_nt[nt] / h->networks[nt].total_quota_in;
-    }
+  {
+    cnt.scale_out[nt] =
+      1.0 * cnt.bw_out_by_nt[nt] / h->networks[nt].total_quota_out;
+    cnt.scale_in[nt] =
+      1.0 * cnt.bw_in_by_nt[nt] / h->networks[nt].total_quota_in;
+  }
   /* recalculate allocations, considering scaling factor, and
      update transport if the change is significant */
-  GNUNET_CONTAINER_multipeermap_iterate(h->peers, &update_allocation, &cnt);
+  GNUNET_CONTAINER_multipeermap_iterate (h->peers, &update_allocation, &cnt);
 }
 
 
@@ -862,15 +868,15 @@ update(struct SimpleHandle *h)
  * @return plugin's internal representation, or NULL
  */
 static struct GNUNET_ATS_PreferenceHandle *
-simple_preference_add(void *cls, const struct GNUNET_ATS_Preference *pref)
+simple_preference_add (void *cls, const struct GNUNET_ATS_Preference *pref)
 {
   struct SimpleHandle *h = cls;
-  struct Peer *p = peer_add(h, &pref->peer);
+  struct Peer *p = peer_add (h, &pref->peer);
 
-  GNUNET_assert(pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
-  p->bw_by_pk[pref->pk] += ntohl(pref->bw.value__);
-  h->bw_by_pk[pref->pk] += ntohl(pref->bw.value__);
-  update(h);
+  GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
+  p->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
+  h->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
+  update (h);
   return NULL;
 }
 
@@ -884,20 +890,20 @@ simple_preference_add(void *cls, const struct GNUNET_ATS_Preference *pref)
  * @return plugin's internal representation, or NULL
  */
 static void
-simple_preference_del(void *cls,
-                      struct GNUNET_ATS_PreferenceHandle *ph,
-                      const struct GNUNET_ATS_Preference *pref)
+simple_preference_del (void *cls,
+                       struct GNUNET_ATS_PreferenceHandle *ph,
+                       const struct GNUNET_ATS_Preference *pref)
 {
   struct SimpleHandle *h = cls;
-  struct Peer *p = lookup_peer(h, &pref->peer);
-
-  GNUNET_assert(NULL != p);
-  GNUNET_assert(pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
-  p->bw_by_pk[pref->pk] -= ntohl(pref->bw.value__);
-  h->bw_by_pk[pref->pk] -= ntohl(pref->bw.value__);
-  if ((0 == p->bw_by_pk[pref->pk]) && (GNUNET_YES == peer_test_dead(p)))
-    peer_free(p);
-  update(h);
+  struct Peer *p = lookup_peer (h, &pref->peer);
+
+  GNUNET_assert (NULL != p);
+  GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
+  p->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
+  h->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
+  if ((0 == p->bw_by_pk[pref->pk]) && (GNUNET_YES == peer_test_dead (p)))
+    peer_free (p);
+  update (h);
 }
 
 
@@ -911,50 +917,50 @@ simple_preference_del(void *cls,
  * @return handle by which the plugin will identify this session
  */
 static struct GNUNET_ATS_SessionHandle *
-simple_session_add(void *cls,
-                   const struct GNUNET_ATS_SessionData *data,
-                   const char *address)
+simple_session_add (void *cls,
+                    const struct GNUNET_ATS_SessionData *data,
+                    const char *address)
 {
   struct SimpleHandle *h = cls;
-  struct Peer *p = peer_add(h, &data->peer);
+  struct Peer *p = peer_add (h, &data->peer);
   struct Hello *hello;
   size_t alen;
   struct GNUNET_ATS_SessionHandle *sh;
 
   /* setup session handle */
-  GNUNET_assert(NULL != data);
+  GNUNET_assert (NULL != data);
   if (NULL == address)
     alen = 0;
   else
-    alen = strlen(address) + 1;
-  sh = GNUNET_malloc(sizeof(struct GNUNET_ATS_SessionHandle) + alen);
+    alen = strlen (address) + 1;
+  sh = GNUNET_malloc (sizeof(struct GNUNET_ATS_SessionHandle) + alen);
   sh->peer = p;
   sh->session = data->session;
   sh->data = data;
   if (NULL == address)
-    {
-      sh->address = NULL;
-    }
+  {
+    sh->address = NULL;
+  }
   else
-    {
-      memcpy(&sh[1], address, alen);
-      sh->address = (const char *)&sh[1];
-    }
-  GNUNET_CONTAINER_DLL_insert(p->sh_head, p->sh_tail, sh);
+  {
+    memcpy (&sh[1], address, alen);
+    sh->address = (const char *) &sh[1];
+  }
+  GNUNET_CONTAINER_DLL_insert (p->sh_head, p->sh_tail, sh);
   if (NULL != address)
+  {
+    /* match HELLO */
+    hello = p->h_head;
+    while ((NULL != hello) && (0 != strcmp (address, hello->address)))
+      hello = hello->next;
+    if (NULL != hello)
     {
-      /* match HELLO */
-      hello = p->h_head;
-      while ((NULL != hello) && (0 != strcmp(address, hello->address)))
-        hello = hello->next;
-      if (NULL != hello)
-        {
-          hello->sh = sh;
-          hello->backoff = GNUNET_TIME_UNIT_ZERO;
-          sh->hello = hello;
-        }
+      hello->sh = sh;
+      hello->backoff = GNUNET_TIME_UNIT_ZERO;
+      sh->hello = hello;
     }
-  update(h);
+  }
+  update (h);
   return sh;
 }
 
@@ -968,15 +974,15 @@ simple_session_add(void *cls,
  * @param data performance characteristics of @a sh
  */
 static void
-simple_session_update(void *cls,
-                      struct GNUNET_ATS_SessionHandle *sh,
-                      const struct GNUNET_ATS_SessionData *data)
+simple_session_update (void *cls,
+                       struct GNUNET_ATS_SessionHandle *sh,
+                       const struct GNUNET_ATS_SessionData *data)
 {
   struct SimpleHandle *h = cls;
 
-  GNUNET_assert(NULL != data);
+  GNUNET_assert (NULL != data);
   sh->data = data; /* this statement should not really do anything... */
-  update(h);
+  update (h);
 }
 
 
@@ -988,30 +994,30 @@ simple_session_update(void *cls,
  * @param data (last) performance characteristics of @a sh
  */
 static void
-simple_session_del(void *cls,
-                   struct GNUNET_ATS_SessionHandle *sh,
-                   const struct GNUNET_ATS_SessionData *data)
+simple_session_del (void *cls,
+                    struct GNUNET_ATS_SessionHandle *sh,
+                    const struct GNUNET_ATS_SessionData *data)
 {
   struct SimpleHandle *h = cls;
   struct Peer *p = sh->peer;
   struct Hello *hello = sh->hello;
 
   /* clean up sh */
-  GNUNET_CONTAINER_DLL_remove(p->sh_head, p->sh_tail, sh);
+  GNUNET_CONTAINER_DLL_remove (p->sh_head, p->sh_tail, sh);
   if (NULL != hello)
-    {
-      GNUNET_assert(sh == hello->sh);
-      hello->sh = NULL;
-      /* session went down, if necessary restart suggesting
-         addresses */
-      if (NULL == p->task)
-        p->task = GNUNET_SCHEDULER_add_now(&suggest_start_cb, p);
-    }
-  GNUNET_free(sh);
+  {
+    GNUNET_assert (sh == hello->sh);
+    hello->sh = NULL;
+    /* session went down, if necessary restart suggesting
+       addresses */
+    if (NULL == p->task)
+      p->task = GNUNET_SCHEDULER_add_now (&suggest_start_cb, p);
+  }
+  GNUNET_free (sh);
   /* del peer if otherwise dead */
-  if ((NULL == p->sh_head) && (GNUNET_YES == peer_test_dead(p)))
-    peer_free(p);
-  update(h);
+  if ((NULL == p->sh_head) && (GNUNET_YES == peer_test_dead (p)))
+    peer_free (p);
+  update (h);
 }
 
 
@@ -1026,16 +1032,16 @@ simple_session_del(void *cls,
  * @return the `struct SimpleHandle` to pass as a closure
  */
 void *
-libgnunet_plugin_ats2_simple_init(void *cls)
+libgnunet_plugin_ats2_simple_init (void *cls)
 {
   static struct GNUNET_ATS_SolverFunctions sf;
   struct GNUNET_ATS_PluginEnvironment *env = cls;
   struct SimpleHandle *s;
 
-  s = GNUNET_new(struct SimpleHandle);
+  s = GNUNET_new (struct SimpleHandle);
   s->env = env;
-  s->peers = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_YES);
-  s->ps = GNUNET_PEERSTORE_connect(env->cfg);
+  s->peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
+  s->ps = GNUNET_PEERSTORE_connect (env->cfg);
   sf.cls = s;
   sf.preference_add = &simple_preference_add;
   sf.preference_del = &simple_preference_del;
@@ -1043,18 +1049,18 @@ libgnunet_plugin_ats2_simple_init(void *cls)
   sf.session_update = &simple_session_update;
   sf.session_del = &simple_session_del;
   for (enum GNUNET_NetworkType nt = 0; nt < GNUNET_NT_COUNT; nt++)
+  {
+    const char *name = GNUNET_NT_to_string (nt);
+
+    if (NULL == name)
     {
-      const char *name = GNUNET_NT_to_string(nt);
-
-      if (NULL == name)
-        {
-          GNUNET_break(0);
-          break;
-        }
-      get_quota(env->cfg, name, "IN", &s->networks[nt].total_quota_in);
-      get_quota(env->cfg, name, "OUT", &s->networks[nt].total_quota_out);
-      s->networks[nt].type = nt;
+      GNUNET_break (0);
+      break;
     }
+    get_quota (env->cfg, name, "IN", &s->networks[nt].total_quota_in);
+    get_quota (env->cfg, name, "OUT", &s->networks[nt].total_quota_out);
+    s->networks[nt].type = nt;
+  }
   return &sf;
 }
 
@@ -1065,15 +1071,15 @@ libgnunet_plugin_ats2_simple_init(void *cls)
  * @param cls return value from #libgnunet_plugin_ats_proportional_init()
  */
 void *
-libgnunet_plugin_ats2_simple_done(void *cls)
+libgnunet_plugin_ats2_simple_done (void *cls)
 {
   struct GNUNET_ATS_SolverFunctions *sf = cls;
   struct SimpleHandle *s = sf->cls;
 
-  GNUNET_break(0 == GNUNET_CONTAINER_multipeermap_size(s->peers));
-  GNUNET_CONTAINER_multipeermap_destroy(s->peers);
-  GNUNET_PEERSTORE_disconnect(s->ps, GNUNET_NO);
-  GNUNET_free(s);
+  GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (s->peers));
+  GNUNET_CONTAINER_multipeermap_destroy (s->peers);
+  GNUNET_PEERSTORE_disconnect (s->ps, GNUNET_NO);
+  GNUNET_free (s);
   return NULL;
 }
 
diff --git a/src/ats/plugin_ats_mlp.c b/src/ats/plugin_ats_mlp.c
index 8d3c9e23a..6ab823b1e 100644
--- a/src/ats/plugin_ats_mlp.c
+++ b/src/ats/plugin_ats_mlp.c
@@ -39,7 +39,8 @@
 
 #define MLP_AVERAGING_QUEUE_LENGTH 3
 
-#define MLP_MAX_EXEC_DURATION   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10)
+#define MLP_MAX_EXEC_DURATION   GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 10)
 #define MLP_MAX_ITERATIONS      4096
 
 #define MLP_DEFAULT_D 1.0
@@ -54,14 +55,16 @@
 #define GLP_YES 1.0
 #define GLP_NO  0.0
 
-enum MLP_Output_Format {
+enum MLP_Output_Format
+{
   MLP_MPS,
   MLP_CPLEX,
   MLP_GLPK
 };
 
 
-enum QualityMetrics {
+enum QualityMetrics
+{
   RQ_QUALITY_METRIC_DELAY = 0,
   RQ_QUALITY_METRIC_DISTANCE = 1,
   RQ_QUALITY_METRIC_COUNT = 2
@@ -69,24 +72,25 @@ enum QualityMetrics {
 
 
 static const char *
-print_quality_type(enum QualityMetrics qm)
+print_quality_type (enum QualityMetrics qm)
 {
   switch (qm)
-    {
-    case RQ_QUALITY_METRIC_DELAY:
-      return "delay";
+  {
+  case RQ_QUALITY_METRIC_DELAY:
+    return "delay";
 
-    case RQ_QUALITY_METRIC_DISTANCE:
-      return "distance";
+  case RQ_QUALITY_METRIC_DISTANCE:
+    return "distance";
 
-    default:
-      GNUNET_break(0);
-      return NULL;
-    }
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
 }
 
 
-struct MLP_Solution {
+struct MLP_Solution
+{
   int lp_res;
   int lp_presolv;
   int mip_res;
@@ -105,7 +109,8 @@ struct MLP_Solution {
   int n_addresses;
 };
 
-struct ATS_Peer {
+struct ATS_Peer
+{
   struct GNUNET_PeerIdentity id;
 
   /* Was this peer already added to the current problem? */
@@ -121,7 +126,8 @@ struct ATS_Peer {
   double f;
 };
 
-struct MLP_Problem {
+struct MLP_Problem
+{
   /**
    * GLPK (MLP) problem object
    */
@@ -169,7 +175,8 @@ struct MLP_Problem {
   double *ar;
 };
 
-struct MLP_Variables {
+struct MLP_Variables
+{
   /* Big M value for bandwidth capping */
   double BIG_M;
 
@@ -225,7 +232,8 @@ struct MLP_Variables {
 /**
  * MLP Handle
  */
-struct GAS_MLP_Handle {
+struct GAS_MLP_Handle
+{
   struct GNUNET_ATS_PluginEnvironment *env;
 
   /**
@@ -360,7 +368,8 @@ struct GAS_MLP_Handle {
 /**
  * Address specific MLP information
  */
-struct MLP_information {
+struct MLP_information
+{
   /**
    * Bandwidth assigned outbound
    */
@@ -503,7 +512,7 @@ struct MLP_information {
 
  */
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-mlp", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-mlp", __VA_ARGS__)
 
 /**
  * Print debug output for mlp problem creation
@@ -518,12 +527,12 @@ struct MLP_information {
  * @return 0: glpk prints output on terminal, 0 != surpress output
  */
 static int
-mlp_term_hook(void *info, const char *s)
+mlp_term_hook (void *info, const char *s)
 {
   struct GAS_MLP_Handle *mlp = info;
 
   if (mlp->opt_dbg_glpk_verbose)
-    LOG(GNUNET_ERROR_TYPE_ERROR, "%s", s);
+    LOG (GNUNET_ERROR_TYPE_ERROR, "%s", s);
   return 1;
 }
 
@@ -537,9 +546,9 @@ mlp_term_hook(void *info, const char *s)
  * @return #GNUNET_OK
  */
 static int
-reset_peers(void *cls,
-            const struct GNUNET_PeerIdentity *key,
-            void *value)
+reset_peers (void *cls,
+             const struct GNUNET_PeerIdentity *key,
+             void *value)
 {
   struct ATS_Peer *peer = value;
 
@@ -553,38 +562,38 @@ reset_peers(void *cls,
  * @param mlp the MLP handle
  */
 static void
-mlp_delete_problem(struct GAS_MLP_Handle *mlp)
+mlp_delete_problem (struct GAS_MLP_Handle *mlp)
 {
   int c;
 
   if (mlp == NULL)
     return;
   if (mlp->p.prob != NULL)
-    {
-      glp_delete_prob(mlp->p.prob);
-      mlp->p.prob = NULL;
-    }
+  {
+    glp_delete_prob (mlp->p.prob);
+    mlp->p.prob = NULL;
+  }
 
   /* delete row index */
   if (mlp->p.ia != NULL)
-    {
-      GNUNET_free(mlp->p.ia);
-      mlp->p.ia = NULL;
-    }
+  {
+    GNUNET_free (mlp->p.ia);
+    mlp->p.ia = NULL;
+  }
 
   /* delete column index */
   if (mlp->p.ja != NULL)
-    {
-      GNUNET_free(mlp->p.ja);
-      mlp->p.ja = NULL;
-    }
+  {
+    GNUNET_free (mlp->p.ja);
+    mlp->p.ja = NULL;
+  }
 
   /* delete coefficients */
   if (mlp->p.ar != NULL)
-    {
-      GNUNET_free(mlp->p.ar);
-      mlp->p.ar = NULL;
-    }
+  {
+    GNUNET_free (mlp->p.ar);
+    mlp->p.ar = NULL;
+  }
   mlp->p.ci = 0;
   mlp->p.prob = NULL;
 
@@ -601,8 +610,8 @@ mlp_delete_problem(struct GAS_MLP_Handle *mlp)
   mlp->p.ci = MLP_UNDEFINED;
 
 
-  GNUNET_CONTAINER_multipeermap_iterate(mlp->requested_peers,
-                                        &reset_peers, NULL);
+  GNUNET_CONTAINER_multipeermap_iterate (mlp->requested_peers,
+                                         &reset_peers, NULL);
 }
 
 
@@ -612,32 +621,32 @@ mlp_delete_problem(struct GAS_MLP_Handle *mlp)
  * @return string with result
  */
 static const char *
-mlp_status_to_string(int retcode)
+mlp_status_to_string (int retcode)
 {
   switch (retcode)
-    {
-    case GLP_UNDEF:
-      return "solution is undefined";
+  {
+  case GLP_UNDEF:
+    return "solution is undefined";
 
-    case GLP_FEAS:
-      return "solution is feasible";
+  case GLP_FEAS:
+    return "solution is feasible";
 
-    case GLP_INFEAS:
-      return "solution is infeasible";
+  case GLP_INFEAS:
+    return "solution is infeasible";
 
-    case GLP_NOFEAS:
-      return "no feasible solution exists";
+  case GLP_NOFEAS:
+    return "no feasible solution exists";
 
-    case GLP_OPT:
-      return "solution is optimal";
+  case GLP_OPT:
+    return "solution is optimal";
 
-    case GLP_UNBND:
-      return "solution is unbounded";
+  case GLP_UNBND:
+    return "solution is unbounded";
 
-    default:
-      GNUNET_break(0);
-      return "unknown error";
-    }
+  default:
+    GNUNET_break (0);
+    return "unknown error";
+  }
 }
 
 
@@ -647,134 +656,142 @@ mlp_status_to_string(int retcode)
  * @return string with result
  */
 static const char *
-mlp_solve_to_string(int retcode)
+mlp_solve_to_string (int retcode)
 {
   switch (retcode)
-    {
-    case 0:
-      return "ok";
+  {
+  case 0:
+    return "ok";
 
-    case GLP_EBADB:
-      return "invalid basis";
+  case GLP_EBADB:
+    return "invalid basis";
 
-    case GLP_ESING:
-      return "singular matrix";
+  case GLP_ESING:
+    return "singular matrix";
 
-    case GLP_ECOND:
-      return "ill-conditioned matrix";
+  case GLP_ECOND:
+    return "ill-conditioned matrix";
 
-    case GLP_EBOUND:
-      return "invalid bounds";
+  case GLP_EBOUND:
+    return "invalid bounds";
 
-    case GLP_EFAIL:
-      return "solver failed";
+  case GLP_EFAIL:
+    return "solver failed";
 
-    case GLP_EOBJLL:
-      return "objective lower limit reached";
+  case GLP_EOBJLL:
+    return "objective lower limit reached";
 
-    case GLP_EOBJUL:
-      return "objective upper limit reached";
+  case GLP_EOBJUL:
+    return "objective upper limit reached";
 
-    case GLP_EITLIM:
-      return "iteration limit exceeded";
+  case GLP_EITLIM:
+    return "iteration limit exceeded";
 
-    case GLP_ETMLIM:
-      return "time limit exceeded";
+  case GLP_ETMLIM:
+    return "time limit exceeded";
 
-    case GLP_ENOPFS:
-      return "no primal feasible solution";
+  case GLP_ENOPFS:
+    return "no primal feasible solution";
 
-    case GLP_ENODFS:
-      return "no dual feasible solution";
+  case GLP_ENODFS:
+    return "no dual feasible solution";
 
-    case GLP_EROOT:
-      return "root LP optimum not provided";
+  case GLP_EROOT:
+    return "root LP optimum not provided";
 
-    case GLP_ESTOP:
-      return "search terminated by application";
+  case GLP_ESTOP:
+    return "search terminated by application";
 
-    case GLP_EMIPGAP:
-      return "relative mip gap tolerance reached";
+  case GLP_EMIPGAP:
+    return "relative mip gap tolerance reached";
 
-    case GLP_ENOFEAS:
-      return "no dual feasible solution";
+  case GLP_ENOFEAS:
+    return "no dual feasible solution";
 
-    case GLP_ENOCVG:
-      return "no convergence";
+  case GLP_ENOCVG:
+    return "no convergence";
 
-    case GLP_EINSTAB:
-      return "numerical instability";
+  case GLP_EINSTAB:
+    return "numerical instability";
 
-    case GLP_EDATA:
-      return "invalid data";
+  case GLP_EDATA:
+    return "invalid data";
 
-    case GLP_ERANGE:
-      return "result out of range";
+  case GLP_ERANGE:
+    return "result out of range";
 
-    default:
-      GNUNET_break(0);
-      return "unknown error";
-    }
+  default:
+    GNUNET_break (0);
+    return "unknown error";
+  }
 }
 
 
-struct CountContext {
+struct CountContext
+{
   const struct GNUNET_CONTAINER_MultiPeerMap *map;
   int result;
 };
 
 static int
-mlp_create_problem_count_addresses_it(void *cls,
-                                      const struct GNUNET_PeerIdentity *key,
-                                      void *value)
+mlp_create_problem_count_addresses_it (void *cls,
+                                       const struct GNUNET_PeerIdentity *key,
+                                       void *value)
 {
   struct CountContext *cctx = cls;
 
   /* Check if we have to add this peer due to a pending request */
-  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(cctx->map, key))
+  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (cctx->map, key))
     cctx->result++;
   return GNUNET_OK;
 }
 
 
 static int
-mlp_create_problem_count_addresses(const struct GNUNET_CONTAINER_MultiPeerMap *requested_peers,
-                                   const struct GNUNET_CONTAINER_MultiPeerMap *addresses)
+mlp_create_problem_count_addresses (const struct
+                                    GNUNET_CONTAINER_MultiPeerMap *
+                                    requested_peers,
+                                    const struct
+                                    GNUNET_CONTAINER_MultiPeerMap *addresses)
 {
   struct CountContext cctx;
 
   cctx.map = requested_peers;
   cctx.result = 0;
-  GNUNET_CONTAINER_multipeermap_iterate(addresses,
-                                        &mlp_create_problem_count_addresses_it, &cctx);
+  GNUNET_CONTAINER_multipeermap_iterate (addresses,
+                                         &mlp_create_problem_count_addresses_it,
+                                         &cctx);
   return cctx.result;
 }
 
 
 static int
-mlp_create_problem_count_peers_it(void *cls,
-                                  const struct GNUNET_PeerIdentity *key,
-                                  void *value)
+mlp_create_problem_count_peers_it (void *cls,
+                                   const struct GNUNET_PeerIdentity *key,
+                                   void *value)
 {
   struct CountContext *cctx = cls;
 
   /* Check if we have to addresses for the requested peer */
-  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(cctx->map, key))
+  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (cctx->map, key))
     cctx->result++;
   return GNUNET_OK;
 }
 
 
 static int
-mlp_create_problem_count_peers(const struct GNUNET_CONTAINER_MultiPeerMap *requested_peers,
-                               const struct GNUNET_CONTAINER_MultiPeerMap *addresses)
+mlp_create_problem_count_peers (const struct
+                                GNUNET_CONTAINER_MultiPeerMap *requested_peers,
+                                const struct
+                                GNUNET_CONTAINER_MultiPeerMap *addresses)
 {
   struct CountContext cctx;
 
   cctx.map = addresses;
   cctx.result = 0;
-  GNUNET_CONTAINER_multipeermap_iterate(requested_peers,
-                                        &mlp_create_problem_count_peers_it, &cctx);
+  GNUNET_CONTAINER_multipeermap_iterate (requested_peers,
+                                         &mlp_create_problem_count_peers_it,
+                                         &cctx);
   return cctx.result;
 }
 
@@ -793,9 +810,9 @@ mlp_create_problem_count_peers(const struct GNUNET_CONTAINER_MultiPeerMap *reque
  * on error
  */
 static int
-mlp_create_problem_update_value(struct MLP_Problem *p,
-                                int row, int col, double val,
-                                int line)
+mlp_create_problem_update_value (struct MLP_Problem *p,
+                                 int row, int col, double val,
+                                 int line)
 {
   int c_cols;
   int c_elems;
@@ -805,59 +822,60 @@ mlp_create_problem_update_value(struct MLP_Problem *p,
   double *val_array;
   int *ind_array;
 
-  GNUNET_assert(NULL != p->prob);
+  GNUNET_assert (NULL != p->prob);
 
   /* Get number of columns and prepare data structure */
-  c_cols = glp_get_num_cols(p->prob);
+  c_cols = glp_get_num_cols (p->prob);
   if (0 >= c_cols)
     return GNUNET_SYSERR;
 
-  val_array = GNUNET_malloc((c_cols + 1) * sizeof(double));
-  GNUNET_assert(NULL != val_array);
-  ind_array = GNUNET_malloc((c_cols + 1) * sizeof(int));
-  GNUNET_assert(NULL != ind_array);
+  val_array = GNUNET_malloc ((c_cols + 1) * sizeof(double));
+  GNUNET_assert (NULL != val_array);
+  ind_array = GNUNET_malloc ((c_cols + 1) * sizeof(int));
+  GNUNET_assert (NULL != ind_array);
   /* Extract the row */
 
   /* Update the value */
-  c_elems = glp_get_mat_row(p->prob, row, ind_array, val_array);
+  c_elems = glp_get_mat_row (p->prob, row, ind_array, val_array);
   found = GNUNET_NO;
   for (c1 = 1; c1 < (c_elems + 1); c1++)
+  {
+    if (ind_array[c1] == col)
     {
-      if (ind_array[c1] == col)
-        {
-          found = GNUNET_YES;
-          break;
-        }
+      found = GNUNET_YES;
+      break;
     }
+  }
   if (GNUNET_NO == found)
-    {
-      ind_array[c_elems + 1] = col;
-      val_array[c_elems + 1] = val;
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "[P] Setting value in [%s : %s] to `%.2f'\n",
-          glp_get_row_name(p->prob, row), glp_get_col_name(p->prob, col),
-          val);
-      glp_set_mat_row(p->prob, row, c_elems + 1, ind_array, val_array);
-      GNUNET_free(ind_array);
-      GNUNET_free(val_array);
-      return GNUNET_YES;
-    }
+  {
+    ind_array[c_elems + 1] = col;
+    val_array[c_elems + 1] = val;
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "[P] Setting value in [%s : %s] to `%.2f'\n",
+         glp_get_row_name (p->prob, row), glp_get_col_name (p->prob, col),
+         val);
+    glp_set_mat_row (p->prob, row, c_elems + 1, ind_array, val_array);
+    GNUNET_free (ind_array);
+    GNUNET_free (val_array);
+    return GNUNET_YES;
+  }
   else
-    {
-      /* Update value */
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "[P] Updating value in [%s : %s] from `%.2f' to `%.2f'\n",
-          glp_get_row_name(p->prob, row), glp_get_col_name(p->prob, col),
-          val_array[c1], val);
-      if (val != val_array[c1])
-        res = GNUNET_YES;
-      else
-        res = GNUNET_NO;
-      val_array[c1] = val;
-      /* Update the row in the matrix */
-      glp_set_mat_row(p->prob, row, c_elems, ind_array, val_array);
-    }
-
-  GNUNET_free(ind_array);
-  GNUNET_free(val_array);
+  {
+    /* Update value */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "[P] Updating value in [%s : %s] from `%.2f' to `%.2f'\n",
+         glp_get_row_name (p->prob, row), glp_get_col_name (p->prob, col),
+         val_array[c1], val);
+    if (val != val_array[c1])
+      res = GNUNET_YES;
+    else
+      res = GNUNET_NO;
+    val_array[c1] = val;
+    /* Update the row in the matrix */
+    glp_set_mat_row (p->prob, row, c_elems, ind_array, val_array);
+  }
+
+  GNUNET_free (ind_array);
+  GNUNET_free (val_array);
   return res;
 }
 
@@ -874,89 +892,93 @@ mlp_create_problem_update_value(struct MLP_Problem *p,
  * @param line calling line for debbuging
  */
 static void
-mlp_create_problem_set_value(struct MLP_Problem *p,
-                             int row, int col, double val,
-                             int line)
+mlp_create_problem_set_value (struct MLP_Problem *p,
+                              int row, int col, double val,
+                              int line)
 {
   if ((p->ci) >= p->num_elements)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "[P]: line %u: Request for index %u bigger than array size of %u\n",
-          line, p->ci + 1, p->num_elements);
-      GNUNET_break(0);
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "[P]: line %u: Request for index %u bigger than array size of %u\n",
+         line, p->ci + 1, p->num_elements);
+    GNUNET_break (0);
+    return;
+  }
   if ((0 == row) || (0 == col))
-    {
-      GNUNET_break(0);
-      LOG(GNUNET_ERROR_TYPE_ERROR, "[P]: Invalid call from line %u: row = %u, col = %u\n",
-          line, row, col);
-    }
+  {
+    GNUNET_break (0);
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "[P]: Invalid call from line %u: row = %u, col = %u\n",
+         line, row, col);
+  }
   p->ia[p->ci] = row;
   p->ja[p->ci] = col;
   p->ar[p->ci] = val;
 #if  DEBUG_MLP_PROBLEM_CREATION
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "[P]: line %u: Set value [%u,%u] in index %u ==  %.2f\n",
-      line, p->ia[p->ci], p->ja[p->ci], p->ci, p->ar[p->ci]);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "[P]: line %u: Set value [%u,%u] in index %u ==  %.2f\n",
+       line, p->ia[p->ci], p->ja[p->ci], p->ci, p->ar[p->ci]);
 #endif
   p->ci++;
 }
 
 static int
-mlp_create_problem_create_column(struct MLP_Problem *p, char *name,
-                                 unsigned int type, unsigned int bound, double lb, double ub,
-                                 double coef)
+mlp_create_problem_create_column (struct MLP_Problem *p, char *name,
+                                  unsigned int type, unsigned int bound, double
+                                  lb, double ub,
+                                  double coef)
 {
-  int col = glp_add_cols(p->prob, 1);
+  int col = glp_add_cols (p->prob, 1);
 
-  glp_set_col_name(p->prob, col, name);
-  glp_set_col_bnds(p->prob, col, bound, lb, ub);
-  glp_set_col_kind(p->prob, col, type);
-  glp_set_obj_coef(p->prob, col, coef);
+  glp_set_col_name (p->prob, col, name);
+  glp_set_col_bnds (p->prob, col, bound, lb, ub);
+  glp_set_col_kind (p->prob, col, type);
+  glp_set_obj_coef (p->prob, col, coef);
 #if  DEBUG_MLP_PROBLEM_CREATION
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "[P]: Added column [%u] `%s': %.2f\n",
-      col, name, coef);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "[P]: Added column [%u] `%s': %.2f\n",
+       col, name, coef);
 #endif
   return col;
 }
 
 static int
-mlp_create_problem_create_constraint(struct MLP_Problem *p, char *name,
-                                     unsigned int bound, double lb, double ub)
+mlp_create_problem_create_constraint (struct MLP_Problem *p, char *name,
+                                      unsigned int bound, double lb, double ub)
 {
-  char * op;
-  int row = glp_add_rows(p->prob, 1);
+  char *op;
+  int row = glp_add_rows (p->prob, 1);
 
   /* set row name */
-  glp_set_row_name(p->prob, row, name);
+  glp_set_row_name (p->prob, row, name);
   /* set row bounds: <= 0 */
-  glp_set_row_bnds(p->prob, row, bound, lb, ub);
+  glp_set_row_bnds (p->prob, row, bound, lb, ub);
   switch (bound)
-    {
-    case GLP_UP:
-      GNUNET_asprintf(&op, "-inf <= x <= %.2f", ub);
-      break;
-
-    case GLP_DB:
-      GNUNET_asprintf(&op, "%.2f <= x <= %.2f", lb, ub);
-      break;
-
-    case GLP_FX:
-      GNUNET_asprintf(&op, "%.2f == x == %.2f", lb, ub);
-      break;
-
-    case GLP_LO:
-      GNUNET_asprintf(&op, "%.2f <= x <= inf", lb);
-      break;
-
-    default:
-      GNUNET_asprintf(&op, "ERROR");
-      break;
-    }
+  {
+  case GLP_UP:
+    GNUNET_asprintf (&op, "-inf <= x <= %.2f", ub);
+    break;
+
+  case GLP_DB:
+    GNUNET_asprintf (&op, "%.2f <= x <= %.2f", lb, ub);
+    break;
+
+  case GLP_FX:
+    GNUNET_asprintf (&op, "%.2f == x == %.2f", lb, ub);
+    break;
+
+  case GLP_LO:
+    GNUNET_asprintf (&op, "%.2f <= x <= inf", lb);
+    break;
+
+  default:
+    GNUNET_asprintf (&op, "ERROR");
+    break;
+  }
 #if  DEBUG_MLP_PROBLEM_CREATION
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "[P]: Added row [%u] `%s': %s\n",
-      row, name, op);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "[P]: Added row [%u] `%s': %s\n",
+       row, name, op);
 #endif
-  GNUNET_free(op);
+  GNUNET_free (op);
   return row;
 }
 
@@ -968,9 +990,10 @@ mlp_create_problem_create_constraint(struct MLP_Problem *p, char *name,
  * - Set address dependent entries in problem matrix as well
  */
 static int
-mlp_create_problem_add_address_information(void *cls,
-                                           const struct GNUNET_PeerIdentity *key,
-                                           void *value)
+mlp_create_problem_add_address_information (void *cls,
+                                            const struct
+                                            GNUNET_PeerIdentity *key,
+                                            void *value)
 {
   struct GAS_MLP_Handle *mlp = cls;
   struct MLP_Problem *p = &mlp->p;
@@ -985,68 +1008,72 @@ mlp_create_problem_add_address_information(void *cls,
   int c;
 
   /* Check if we have to add this peer due to a pending request */
-  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(mlp->requested_peers, key))
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (mlp->requested_peers,
+                                                           key))
     return GNUNET_OK;
 
   mlpi = address->solver_information;
   if (NULL == mlpi)
-    {
-      fprintf(stderr, "%s %p\n", GNUNET_i2s(&address->peer), address);
-      GNUNET_break(0);
-      return GNUNET_OK;
-    }
+  {
+    fprintf (stderr, "%s %p\n", GNUNET_i2s (&address->peer), address);
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
 
   addr_net = address->properties.scope;
   for (addr_net_index = 0; addr_net_index < GNUNET_NT_COUNT; addr_net_index++)
-    {
-      if (mlp->pv.quota_index[addr_net_index] == addr_net)
-        break;
-    }
+  {
+    if (mlp->pv.quota_index[addr_net_index] == addr_net)
+      break;
+  }
 
   if (addr_net_index >= GNUNET_NT_COUNT)
-    {
-      GNUNET_break(0);
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
 
   max_quota = 0;
   for (c = 0; c < GNUNET_NT_COUNT; c++)
-    {
-      if (mlp->pv.quota_out[c] > max_quota)
-        max_quota = mlp->pv.quota_out[c];
-      if (mlp->pv.quota_in[c] > max_quota)
-        max_quota = mlp->pv.quota_in[c];
-    }
+  {
+    if (mlp->pv.quota_out[c] > max_quota)
+      max_quota = mlp->pv.quota_out[c];
+    if (mlp->pv.quota_in[c] > max_quota)
+      max_quota = mlp->pv.quota_in[c];
+  }
   if (max_quota > mlp->pv.BIG_M)
-    cur_bigm = (double)mlp->pv.BIG_M;
+    cur_bigm = (double) mlp->pv.BIG_M;
   else
     cur_bigm = max_quota;
 
 
   /* Get peer */
-  peer = GNUNET_CONTAINER_multipeermap_get(mlp->requested_peers, key);
-  GNUNET_assert(NULL != peer);
+  peer = GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers, key);
+  GNUNET_assert (NULL != peer);
   if (peer->processed == GNUNET_NO)
+  {
+    /* Add peer dependent constraints */
+    /* Add c2) One address active per peer */
+    GNUNET_asprintf (&name, "c2_%s", GNUNET_i2s (&address->peer));
+    peer->r_c2 = mlp_create_problem_create_constraint (p, name, GLP_FX, 1.0,
+                                                       1.0);
+    GNUNET_free (name);
+    if (GNUNET_NO == mlp->opt_dbg_feasibility_only)
     {
-      /* Add peer dependent constraints */
-      /* Add c2) One address active per peer */
-      GNUNET_asprintf(&name, "c2_%s", GNUNET_i2s(&address->peer));
-      peer->r_c2 = mlp_create_problem_create_constraint(p, name, GLP_FX, 1.0, 1.0);
-      GNUNET_free(name);
-      if (GNUNET_NO == mlp->opt_dbg_feasibility_only)
-        {
-          if (GNUNET_YES == mlp->opt_dbg_optimize_relativity)
-            {
-              /* Add c9) Relativity */
-              GNUNET_asprintf(&name, "c9_%s", GNUNET_i2s(&address->peer));
-              peer->r_c9 = mlp_create_problem_create_constraint(p, name, GLP_LO, 0.0, 0.0);
-              GNUNET_free(name);
-              /* c9) set coefficient */
-              mlp_create_problem_set_value(p, peer->r_c9, p->c_r, -peer->f, __LINE__);
-            }
-        }
-      peer->processed = GNUNET_YES;
+      if (GNUNET_YES == mlp->opt_dbg_optimize_relativity)
+      {
+        /* Add c9) Relativity */
+        GNUNET_asprintf (&name, "c9_%s", GNUNET_i2s (&address->peer));
+        peer->r_c9 = mlp_create_problem_create_constraint (p, name, GLP_LO, 0.0,
+                                                           0.0);
+        GNUNET_free (name);
+        /* c9) set coefficient */
+        mlp_create_problem_set_value (p, peer->r_c9, p->c_r, -peer->f,
+                                      __LINE__);
+      }
     }
+    peer->processed = GNUNET_YES;
+  }
 
   /* Reset addresses' solver information */
   mlpi->c_b = 0;
@@ -1056,47 +1083,55 @@ mlp_create_problem_add_address_information(void *cls,
   mlpi->r_c3 = 0;
 
   /* Add bandwidth column */
-  GNUNET_asprintf(&name, "b_%s_%s_%p", GNUNET_i2s(&address->peer), address->plugin, address);
+  GNUNET_asprintf (&name, "b_%s_%s_%p", GNUNET_i2s (&address->peer),
+                   address->plugin, address);
   if (GNUNET_NO == mlp->opt_dbg_feasibility_only)
-    {
-      mlpi->c_b = mlp_create_problem_create_column(p, name, GLP_CV, GLP_LO, 0.0, 0.0, 0.0);
-    }
+  {
+    mlpi->c_b = mlp_create_problem_create_column (p, name, GLP_CV, GLP_LO, 0.0,
+                                                  0.0, 0.0);
+  }
   else
-    {
-      /* Maximize for bandwidth assignment in feasibility testing */
-      mlpi->c_b = mlp_create_problem_create_column(p, name, GLP_CV, GLP_LO, 0.0, 0.0, 1.0);
-    }
-  GNUNET_free(name);
+  {
+    /* Maximize for bandwidth assignment in feasibility testing */
+    mlpi->c_b = mlp_create_problem_create_column (p, name, GLP_CV, GLP_LO, 0.0,
+                                                  0.0, 1.0);
+  }
+  GNUNET_free (name);
 
   /* Add address active column */
-  GNUNET_asprintf(&name, "n_%s_%s_%p", GNUNET_i2s(&address->peer), address->plugin, address);
-  mlpi->c_n = mlp_create_problem_create_column(p, name, GLP_IV, GLP_DB, 0.0, 1.0, 0.0);
-  GNUNET_free(name);
+  GNUNET_asprintf (&name, "n_%s_%s_%p", GNUNET_i2s (&address->peer),
+                   address->plugin, address);
+  mlpi->c_n = mlp_create_problem_create_column (p, name, GLP_IV, GLP_DB, 0.0,
+                                                1.0, 0.0);
+  GNUNET_free (name);
 
   /* Add address dependent constraints */
   /* Add c1) bandwidth capping: b_t  + (-M) * n_t <= 0 */
-  GNUNET_asprintf(&name, "c1_%s_%s_%p", GNUNET_i2s(&address->peer), address->plugin, address);
-  mlpi->r_c1 = mlp_create_problem_create_constraint(p, name, GLP_UP, 0.0, 0.0);
-  GNUNET_free(name);
+  GNUNET_asprintf (&name, "c1_%s_%s_%p", GNUNET_i2s (&address->peer),
+                   address->plugin, address);
+  mlpi->r_c1 = mlp_create_problem_create_constraint (p, name, GLP_UP, 0.0, 0.0);
+  GNUNET_free (name);
   /*  c1) set b = 1 coefficient */
-  mlp_create_problem_set_value(p, mlpi->r_c1, mlpi->c_b, 1, __LINE__);
+  mlp_create_problem_set_value (p, mlpi->r_c1, mlpi->c_b, 1, __LINE__);
   /*  c1) set n = - min (M, quota) coefficient */
-  cur_bigm = (double)mlp->pv.quota_out[addr_net_index];
+  cur_bigm = (double) mlp->pv.quota_out[addr_net_index];
   if (cur_bigm > mlp->pv.BIG_M)
-    cur_bigm = (double)mlp->pv.BIG_M;
-  mlp_create_problem_set_value(p, mlpi->r_c1, mlpi->c_n, -cur_bigm, __LINE__);
+    cur_bigm = (double) mlp->pv.BIG_M;
+  mlp_create_problem_set_value (p, mlpi->r_c1, mlpi->c_n, -cur_bigm, __LINE__);
 
   /* Add constraint c 3) minimum bandwidth
    * b_t + (-n_t * b_min) >= 0
    * */
-  GNUNET_asprintf(&name, "c3_%s_%s_%p", GNUNET_i2s(&address->peer), address->plugin, address);
-  mlpi->r_c3 = mlp_create_problem_create_constraint(p, name, GLP_LO, 0.0, 0.0);
-  GNUNET_free(name);
+  GNUNET_asprintf (&name, "c3_%s_%s_%p", GNUNET_i2s (&address->peer),
+                   address->plugin, address);
+  mlpi->r_c3 = mlp_create_problem_create_constraint (p, name, GLP_LO, 0.0, 0.0);
+  GNUNET_free (name);
 
   /*  c3) set b = 1 coefficient */
-  mlp_create_problem_set_value(p, mlpi->r_c3, mlpi->c_b, 1, __LINE__);
+  mlp_create_problem_set_value (p, mlpi->r_c3, mlpi->c_b, 1, __LINE__);
   /*  c3) set n = -b_min coefficient */
-  mlp_create_problem_set_value(p, mlpi->r_c3, mlpi->c_n, -((double )mlp->pv.b_min), __LINE__);
+  mlp_create_problem_set_value (p, mlpi->r_c3, mlpi->c_n,
+                                -((double ) mlp->pv.b_min), __LINE__);
 
 
   /* Set coefficient entries in invariant rows */
@@ -1104,41 +1139,42 @@ mlp_create_problem_add_address_information(void *cls,
   /* Feasbility */
 
   /* c 4) minimum connections */
-  mlp_create_problem_set_value(p, p->r_c4, mlpi->c_n, 1, __LINE__);
+  mlp_create_problem_set_value (p, p->r_c4, mlpi->c_n, 1, __LINE__);
   /* c 2) 1 address peer peer */
-  mlp_create_problem_set_value(p, peer->r_c2, mlpi->c_n, 1, __LINE__);
+  mlp_create_problem_set_value (p, peer->r_c2, mlpi->c_n, 1, __LINE__);
   /* c 10) obey network specific quotas
    * (1)*b_1 + ... + (1)*b_m <= quota_n
    */
-  mlp_create_problem_set_value(p, p->r_quota[addr_net_index], mlpi->c_b, 1, __LINE__);
+  mlp_create_problem_set_value (p, p->r_quota[addr_net_index], mlpi->c_b, 1,
+                                __LINE__);
 
   /* Optimality */
   if (GNUNET_NO == mlp->opt_dbg_feasibility_only)
-    {
-      /* c 6) maximize diversity */
-      mlp_create_problem_set_value(p, p->r_c6, mlpi->c_n, 1, __LINE__);
-      /* c 9) relativity */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_relativity)
-        mlp_create_problem_set_value(p, peer->r_c9, mlpi->c_b, 1, __LINE__);
-      /* c 8) utility */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_utility)
-        mlp_create_problem_set_value(p, p->r_c8, mlpi->c_b, 1, __LINE__);
-      /* c 7) Optimize quality */
-      /* For all quality metrics, set quality of this address */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_quality)
-        {
-          mlp_create_problem_set_value(p,
-                                       p->r_q[RQ_QUALITY_METRIC_DELAY],
-                                       mlpi->c_b,
-                                       address->norm_delay.norm,
-                                       __LINE__);
-          mlp_create_problem_set_value(p,
-                                       p->r_q[RQ_QUALITY_METRIC_DISTANCE],
-                                       mlpi->c_b,
-                                       address->norm_distance.norm,
-                                       __LINE__);
-        }
-    }
+  {
+    /* c 6) maximize diversity */
+    mlp_create_problem_set_value (p, p->r_c6, mlpi->c_n, 1, __LINE__);
+    /* c 9) relativity */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_relativity)
+      mlp_create_problem_set_value (p, peer->r_c9, mlpi->c_b, 1, __LINE__);
+    /* c 8) utility */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_utility)
+      mlp_create_problem_set_value (p, p->r_c8, mlpi->c_b, 1, __LINE__);
+    /* c 7) Optimize quality */
+    /* For all quality metrics, set quality of this address */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_quality)
+    {
+      mlp_create_problem_set_value (p,
+                                    p->r_q[RQ_QUALITY_METRIC_DELAY],
+                                    mlpi->c_b,
+                                    address->norm_delay.norm,
+                                    __LINE__);
+      mlp_create_problem_set_value (p,
+                                    p->r_q[RQ_QUALITY_METRIC_DISTANCE],
+                                    mlpi->c_b,
+                                    address->norm_distance.norm,
+                                    __LINE__);
+    }
+  }
 
   return GNUNET_OK;
 }
@@ -1148,7 +1184,8 @@ mlp_create_problem_add_address_information(void *cls,
  * Create the invariant columns c4, c6, c10, c8, c7
  */
 static void
-mlp_create_problem_add_invariant_rows(struct GAS_MLP_Handle *mlp, struct MLP_Problem *p)
+mlp_create_problem_add_invariant_rows (struct GAS_MLP_Handle *mlp, struct
+                                       MLP_Problem *p)
 {
   int c;
 
@@ -1156,55 +1193,63 @@ mlp_create_problem_add_invariant_rows(struct GAS_MLP_Handle *mlp, struct MLP_Pro
 
   /* Row for c4) minimum connection */
   /* Number of minimum connections is min(|Peers|, n_min) */
-  p->r_c4 = mlp_create_problem_create_constraint(p, "c4", GLP_LO, (mlp->pv.n_min > p->num_peers) ? p->num_peers : mlp->pv.n_min, 0.0);
+  p->r_c4 = mlp_create_problem_create_constraint (p, "c4", GLP_LO,
+                                                  (mlp->pv.n_min >
+                                                   p->num_peers) ?
+                                                  p->num_peers : mlp->pv.n_min,
+                                                  0.0);
 
   /* Rows for c 10) Enforce network quotas */
   for (c = 0; c < GNUNET_NT_COUNT; c++)
-    {
-      char * text;
-      GNUNET_asprintf(&text, "c10_quota_ats_%s",
-                      GNUNET_NT_to_string(mlp->pv.quota_index[c]));
-      p->r_quota[c] = mlp_create_problem_create_constraint(p, text, GLP_DB, 0.0, mlp->pv.quota_out[c]);
-      GNUNET_free(text);
-    }
+  {
+    char *text;
+    GNUNET_asprintf (&text, "c10_quota_ats_%s",
+                     GNUNET_NT_to_string (mlp->pv.quota_index[c]));
+    p->r_quota[c] = mlp_create_problem_create_constraint (p, text, GLP_DB, 0.0,
+                                                          mlp->pv.quota_out[c]);
+    GNUNET_free (text);
+  }
 
   /* Optimality */
   if (GNUNET_NO == mlp->opt_dbg_feasibility_only)
-    {
-      char *name;
-      /* Add row for c6) Maximize for diversity */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_diversity)
-        {
-          p->r_c6 = mlp_create_problem_create_constraint(p, "c6", GLP_FX, 0.0, 0.0);
-          /* Set c6 ) Setting -D */
-          mlp_create_problem_set_value(p, p->r_c6, p->c_d, -1, __LINE__);
-        }
-
-      /* Adding rows for c 8) Maximize utility */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_utility)
-        {
-          p->r_c8 = mlp_create_problem_create_constraint(p, "c8", GLP_FX, 0.0, 0.0);
-          /* -u */
-          mlp_create_problem_set_value(p, p->r_c8, p->c_u, -1, __LINE__);
-        }
-
-      /* For all quality metrics:
-       * c 7) Maximize quality, austerity */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_quality)
-        {
-          for (c = 0; c < mlp->pv.m_q; c++)
-            {
-              GNUNET_asprintf(&name,
-                              "c7_q%i_%s", c,
-                              print_quality_type(c));
-              p->r_q[c] = mlp_create_problem_create_constraint(p, name, GLP_FX, 0.0, 0.0);
-              GNUNET_free(name);
-              mlp_create_problem_set_value(p,
-                                           p->r_q[c],
-                                           p->c_q[c], -1, __LINE__);
-            }
-        }
-    }
+  {
+    char *name;
+    /* Add row for c6) Maximize for diversity */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_diversity)
+    {
+      p->r_c6 = mlp_create_problem_create_constraint (p, "c6", GLP_FX, 0.0,
+                                                      0.0);
+      /* Set c6 ) Setting -D */
+      mlp_create_problem_set_value (p, p->r_c6, p->c_d, -1, __LINE__);
+    }
+
+    /* Adding rows for c 8) Maximize utility */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_utility)
+    {
+      p->r_c8 = mlp_create_problem_create_constraint (p, "c8", GLP_FX, 0.0,
+                                                      0.0);
+      /* -u */
+      mlp_create_problem_set_value (p, p->r_c8, p->c_u, -1, __LINE__);
+    }
+
+    /* For all quality metrics:
+     * c 7) Maximize quality, austerity */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_quality)
+    {
+      for (c = 0; c < mlp->pv.m_q; c++)
+      {
+        GNUNET_asprintf (&name,
+                         "c7_q%i_%s", c,
+                         print_quality_type (c));
+        p->r_q[c] = mlp_create_problem_create_constraint (p, name, GLP_FX, 0.0,
+                                                          0.0);
+        GNUNET_free (name);
+        mlp_create_problem_set_value (p,
+                                      p->r_q[c],
+                                      p->c_q[c], -1, __LINE__);
+      }
+    }
+  }
 }
 
 
@@ -1212,36 +1257,42 @@ mlp_create_problem_add_invariant_rows(struct GAS_MLP_Handle *mlp, struct MLP_Pro
  * Create the invariant columns d, u, r, q0 ... qm
  */
 static void
-mlp_create_problem_add_invariant_columns(struct GAS_MLP_Handle *mlp, struct MLP_Problem *p)
+mlp_create_problem_add_invariant_columns (struct GAS_MLP_Handle *mlp, struct
+                                          MLP_Problem *p)
 {
   if (GNUNET_NO == mlp->opt_dbg_feasibility_only)
-    {
-      char *name;
-      int c;
-
-      /* Diversity d column  */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_diversity)
-        p->c_d = mlp_create_problem_create_column(p, "d", GLP_CV, GLP_LO, 0.0, 0.0, mlp->pv.co_D);
-
-      /* Utilization u column  */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_utility)
-        p->c_u = mlp_create_problem_create_column(p, "u", GLP_CV, GLP_LO, 0.0, 0.0, mlp->pv.co_U);
-
-      /* Relativity r column  */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_relativity)
-        p->c_r = mlp_create_problem_create_column(p, "r", GLP_CV, GLP_LO, 0.0, 0.0, mlp->pv.co_R);
-
-      /* Quality metric columns */
-      if (GNUNET_YES == mlp->opt_dbg_optimize_quality)
-        {
-          for (c = 0; c < mlp->pv.m_q; c++)
-            {
-              GNUNET_asprintf(&name, "q_%u", c);
-              p->c_q[c] = mlp_create_problem_create_column(p, name, GLP_CV, GLP_LO, 0.0, 0.0, mlp->pv.co_Q[c]);
-              GNUNET_free(name);
-            }
-        }
-    }
+  {
+    char *name;
+    int c;
+
+    /* Diversity d column  */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_diversity)
+      p->c_d = mlp_create_problem_create_column (p, "d", GLP_CV, GLP_LO, 0.0,
+                                                 0.0, mlp->pv.co_D);
+
+    /* Utilization u column  */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_utility)
+      p->c_u = mlp_create_problem_create_column (p, "u", GLP_CV, GLP_LO, 0.0,
+                                                 0.0, mlp->pv.co_U);
+
+    /* Relativity r column  */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_relativity)
+      p->c_r = mlp_create_problem_create_column (p, "r", GLP_CV, GLP_LO, 0.0,
+                                                 0.0, mlp->pv.co_R);
+
+    /* Quality metric columns */
+    if (GNUNET_YES == mlp->opt_dbg_optimize_quality)
+    {
+      for (c = 0; c < mlp->pv.m_q; c++)
+      {
+        GNUNET_asprintf (&name, "q_%u", c);
+        p->c_q[c] = mlp_create_problem_create_column (p, name, GLP_CV, GLP_LO,
+                                                      0.0, 0.0,
+                                                      mlp->pv.co_Q[c]);
+        GNUNET_free (name);
+      }
+    }
+  }
 }
 
 
@@ -1252,73 +1303,76 @@ mlp_create_problem_add_invariant_columns(struct GAS_MLP_Handle *mlp, struct MLP_
  * @return #GNUNET_OK or #GNUNET_SYSERR
  */
 static int
-mlp_create_problem(struct GAS_MLP_Handle *mlp)
+mlp_create_problem (struct GAS_MLP_Handle *mlp)
 {
   struct MLP_Problem *p = &mlp->p;
   int res = GNUNET_OK;
 
-  GNUNET_assert(p->prob == NULL);
-  GNUNET_assert(p->ia == NULL);
-  GNUNET_assert(p->ja == NULL);
-  GNUNET_assert(p->ar == NULL);
+  GNUNET_assert (p->prob == NULL);
+  GNUNET_assert (p->ia == NULL);
+  GNUNET_assert (p->ja == NULL);
+  GNUNET_assert (p->ar == NULL);
   /* Reset MLP problem struct */
 
   /* create the glpk problem */
-  p->prob = glp_create_prob();
-  GNUNET_assert(NULL != p->prob);
-  p->num_peers = mlp_create_problem_count_peers(mlp->requested_peers, mlp->env->addresses);
-  p->num_addresses = mlp_create_problem_count_addresses(mlp->requested_peers,
-                                                        mlp->env->addresses);
+  p->prob = glp_create_prob ();
+  GNUNET_assert (NULL != p->prob);
+  p->num_peers = mlp_create_problem_count_peers (mlp->requested_peers,
+                                                 mlp->env->addresses);
+  p->num_addresses = mlp_create_problem_count_addresses (mlp->requested_peers,
+                                                         mlp->env->addresses);
 
   /* Create problem matrix: 10 * #addresses + #q * #addresses + #q, + #peer + 2 + 1 */
-  p->num_elements = (10 * p->num_addresses + mlp->pv.m_q * p->num_addresses +
-                     mlp->pv.m_q + p->num_peers + 2 + 1);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Rebuilding problem for %u peer(s) and %u addresse(s) and %u quality metrics == %u elements\n",
-      p->num_peers,
-      p->num_addresses,
-      mlp->pv.m_q,
-      p->num_elements);
+  p->num_elements = (10 * p->num_addresses + mlp->pv.m_q * p->num_addresses
+                     + mlp->pv.m_q + p->num_peers + 2 + 1);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Rebuilding problem for %u peer(s) and %u addresse(s) and %u quality metrics == %u elements\n",
+       p->num_peers,
+       p->num_addresses,
+       mlp->pv.m_q,
+       p->num_elements);
 
   /* Set a problem name */
-  glp_set_prob_name(p->prob, "GNUnet ATS bandwidth distribution");
+  glp_set_prob_name (p->prob, "GNUnet ATS bandwidth distribution");
   /* Set optimization direction to maximize */
-  glp_set_obj_dir(p->prob, GLP_MAX);
+  glp_set_obj_dir (p->prob, GLP_MAX);
 
   /* Create problem matrix */
   /* last +1 caused by glpk index starting with one: [1..elements]*/
   p->ci = 1;
   /* row index */
-  p->ia = GNUNET_malloc(p->num_elements * sizeof(int));
+  p->ia = GNUNET_malloc (p->num_elements * sizeof(int));
   /* column index */
-  p->ja = GNUNET_malloc(p->num_elements * sizeof(int));
+  p->ja = GNUNET_malloc (p->num_elements * sizeof(int));
   /* coefficient */
-  p->ar = GNUNET_malloc(p->num_elements * sizeof(double));
+  p->ar = GNUNET_malloc (p->num_elements * sizeof(double));
 
   if ((NULL == p->ia) || (NULL == p->ja) || (NULL == p->ar))
-    {
-      LOG(GNUNET_ERROR_TYPE_ERROR, _("Problem size too large, cannot allocate memory!\n"));
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, _ (
+           "Problem size too large, cannot allocate memory!\n"));
+    return GNUNET_SYSERR;
+  }
 
   /* Adding invariant columns */
-  mlp_create_problem_add_invariant_columns(mlp, p);
+  mlp_create_problem_add_invariant_columns (mlp, p);
 
   /* Adding address independent constraint rows */
-  mlp_create_problem_add_invariant_rows(mlp, p);
+  mlp_create_problem_add_invariant_rows (mlp, p);
 
   /* Adding address dependent columns constraint rows */
-  GNUNET_CONTAINER_multipeermap_iterate(mlp->env->addresses,
-                                        &mlp_create_problem_add_address_information,
-                                        mlp);
+  GNUNET_CONTAINER_multipeermap_iterate (mlp->env->addresses,
+                                         &
+                                         mlp_create_problem_add_address_information,
+                                         mlp);
 
   /* Load the matrix */
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Loading matrix\n");
-  glp_load_matrix(p->prob, (p->ci) - 1, p->ia, p->ja, p->ar);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Loading matrix\n");
+  glp_load_matrix (p->prob, (p->ci) - 1, p->ia, p->ja, p->ar);
   if (GNUNET_YES == mlp->opt_dbg_autoscale_problem)
-    {
-      glp_scale_prob(p->prob, GLP_SF_AUTO);
-    }
+  {
+    glp_scale_prob (p->prob, GLP_SF_AUTO);
+  }
 
   return res;
 }
@@ -1331,37 +1385,37 @@ mlp_create_problem(struct GAS_MLP_Handle *mlp)
  * @return #GNUNET_OK if could be solved, #GNUNET_SYSERR on failure
  */
 static int
-mlp_solve_lp_problem(struct GAS_MLP_Handle *mlp)
+mlp_solve_lp_problem (struct GAS_MLP_Handle *mlp)
 {
   int res = 0;
   int res_status = 0;
 
-  res = glp_simplex(mlp->p.prob, &mlp->control_param_lp);
+  res = glp_simplex (mlp->p.prob, &mlp->control_param_lp);
   if (0 == res)
-    LOG(GNUNET_ERROR_TYPE_DEBUG, "Solving LP problem: %s\n",
-        mlp_solve_to_string(res));
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Solving LP problem: %s\n",
+         mlp_solve_to_string (res));
   else
-    LOG(GNUNET_ERROR_TYPE_DEBUG, "Solving LP problem failed: %s\n",
-        mlp_solve_to_string(res));
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Solving LP problem failed: %s\n",
+         mlp_solve_to_string (res));
 
   /* Analyze problem status  */
-  res_status = glp_get_status(mlp->p.prob);
+  res_status = glp_get_status (mlp->p.prob);
   switch (res_status)
-    {
-    case GLP_OPT: /* solution is optimal */
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Solving LP problem: %s, %s\n",
-          mlp_solve_to_string(res),
-          mlp_status_to_string(res_status));
-      return GNUNET_OK;
+  {
+  case GLP_OPT:   /* solution is optimal */
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Solving LP problem: %s, %s\n",
+         mlp_solve_to_string (res),
+         mlp_status_to_string (res_status));
+    return GNUNET_OK;
 
-    default:
-      LOG(GNUNET_ERROR_TYPE_ERROR,
-          "Solving LP problem failed: %s %s\n",
-          mlp_solve_to_string(res),
-          mlp_status_to_string(res_status));
-      return GNUNET_SYSERR;
-    }
+  default:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Solving LP problem failed: %s %s\n",
+         mlp_solve_to_string (res),
+         mlp_status_to_string (res_status));
+    return GNUNET_SYSERR;
+  }
 }
 
 
@@ -1374,9 +1428,9 @@ mlp_solve_lp_problem(struct GAS_MLP_Handle *mlp)
  * @return #GNUNET_OK to continue
  */
 static int
-mlp_propagate_results(void *cls,
-                      const struct GNUNET_PeerIdentity *key,
-                      void *value)
+mlp_propagate_results (void *cls,
+                       const struct GNUNET_PeerIdentity *key,
+                       void *value)
 {
   struct GAS_MLP_Handle *mlp = cls;
   struct ATS_Address *address;
@@ -1386,28 +1440,30 @@ mlp_propagate_results(void *cls,
   double mlp_use = MLP_NaN;
 
   /* Check if we have to add this peer due to a pending request */
-  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(mlp->requested_peers,
-                                                          key))
-    {
-      return GNUNET_OK;
-    }
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (mlp->requested_peers,
+                                                           key))
+  {
+    return GNUNET_OK;
+  }
   address = value;
-  GNUNET_assert(address->solver_information != NULL);
+  GNUNET_assert (address->solver_information != NULL);
   mlpi = address->solver_information;
 
-  mlp_bw_in = glp_mip_col_val(mlp->p.prob, mlpi->c_b);/* FIXME */
-  if (mlp_bw_in > (double)UINT32_MAX)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Overflow in assigned bandwidth, reducing ...\n");
-      mlp_bw_in = (double)UINT32_MAX;
-    }
-  mlp_bw_out = glp_mip_col_val(mlp->p.prob, mlpi->c_b);
-  if (mlp_bw_out > (double)UINT32_MAX)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Overflow in assigned bandwidth, reducing ...\n");
-      mlp_bw_out = (double)UINT32_MAX;
-    }
-  mlp_use = glp_mip_col_val(mlp->p.prob, mlpi->c_n);
+  mlp_bw_in = glp_mip_col_val (mlp->p.prob, mlpi->c_b);/* FIXME */
+  if (mlp_bw_in > (double) UINT32_MAX)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Overflow in assigned bandwidth, reducing ...\n");
+    mlp_bw_in = (double) UINT32_MAX;
+  }
+  mlp_bw_out = glp_mip_col_val (mlp->p.prob, mlpi->c_b);
+  if (mlp_bw_out > (double) UINT32_MAX)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Overflow in assigned bandwidth, reducing ...\n");
+    mlp_bw_out = (double) UINT32_MAX;
+  }
+  mlp_use = glp_mip_col_val (mlp->p.prob, mlpi->c_n);
 
   /*
    * Debug: solution
@@ -1417,155 +1473,161 @@ mlp_propagate_results(void *cls,
    */
 
   if (GLP_YES == mlp_use)
-    {
-      /* This address was selected by the solver to be used */
-      mlpi->n = GNUNET_YES;
-      if (GNUNET_NO == address->active)
-        {
-          /* Address was not used before, enabling address */
-          LOG(GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : enabling address\n",
-              (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
-          address->active = GNUNET_YES;
-          address->assigned_bw_in = mlp_bw_in;
-          mlpi->b_in = mlp_bw_in;
-          address->assigned_bw_out = mlp_bw_out;
-          mlpi->b_out = mlp_bw_out;
-          if ((NULL == mlp->exclude_peer) || (0 != GNUNET_memcmp(&address->peer, mlp->exclude_peer)))
-            mlp->env->bandwidth_changed_cb(mlp->env->cls, address);
-          return GNUNET_OK;
-        }
-      else if (GNUNET_YES == address->active)
-        {
-          /* Address was used before, check for bandwidth change */
-          if ((mlp_bw_out != address->assigned_bw_out) ||
-              (mlp_bw_in != address->assigned_bw_in))
-            {
-              LOG(GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : bandwidth changed\n",
-                  (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
-              address->assigned_bw_in = mlp_bw_in;
-              mlpi->b_in = mlp_bw_in;
-              address->assigned_bw_out = mlp_bw_out;
-              mlpi->b_out = mlp_bw_out;
-              if ((NULL == mlp->exclude_peer) || (0 != GNUNET_memcmp(&address->peer, mlp->exclude_peer)))
-                mlp->env->bandwidth_changed_cb(mlp->env->cls, address);
-              return GNUNET_OK;
-            }
-        }
-      else
-        GNUNET_break(0);
+  {
+    /* This address was selected by the solver to be used */
+    mlpi->n = GNUNET_YES;
+    if (GNUNET_NO == address->active)
+    {
+      /* Address was not used before, enabling address */
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : enabling address\n",
+           (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
+      address->active = GNUNET_YES;
+      address->assigned_bw_in = mlp_bw_in;
+      mlpi->b_in = mlp_bw_in;
+      address->assigned_bw_out = mlp_bw_out;
+      mlpi->b_out = mlp_bw_out;
+      if ((NULL == mlp->exclude_peer) || (0 != GNUNET_memcmp (&address->peer,
+                                                              mlp->exclude_peer)))
+        mlp->env->bandwidth_changed_cb (mlp->env->cls, address);
+      return GNUNET_OK;
     }
+    else if (GNUNET_YES == address->active)
+    {
+      /* Address was used before, check for bandwidth change */
+      if ((mlp_bw_out != address->assigned_bw_out) ||
+          (mlp_bw_in != address->assigned_bw_in))
+      {
+        LOG (GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : bandwidth changed\n",
+             (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
+        address->assigned_bw_in = mlp_bw_in;
+        mlpi->b_in = mlp_bw_in;
+        address->assigned_bw_out = mlp_bw_out;
+        mlpi->b_out = mlp_bw_out;
+        if ((NULL == mlp->exclude_peer) || (0 != GNUNET_memcmp (&address->peer,
+                                                                mlp->
+                                                                exclude_peer)))
+          mlp->env->bandwidth_changed_cb (mlp->env->cls, address);
+        return GNUNET_OK;
+      }
+    }
+    else
+      GNUNET_break (0);
+  }
   else if (GLP_NO == mlp_use)
-    {
-      /* This address was selected by the solver to be not used */
-      mlpi->n = GNUNET_NO;
-      if (GNUNET_NO == address->active)
-        {
-          /* Address was not used before, nothing to do */
-          LOG(GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : no change\n",
-              (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
-          return GNUNET_OK;
-        }
-      else if (GNUNET_YES == address->active)
-        {
-          /* Address was used before, disabling address */
-          LOG(GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : disabling address\n",
-              (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
-          address->active = GNUNET_NO;
-          /* Set bandwidth to 0 */
-          address->assigned_bw_in = 0;
-          mlpi->b_in = 0;
-          address->assigned_bw_out = 0;
-          mlpi->b_out = 0;
-          return GNUNET_OK;
-        }
-      else
-        GNUNET_break(0);
+  {
+    /* This address was selected by the solver to be not used */
+    mlpi->n = GNUNET_NO;
+    if (GNUNET_NO == address->active)
+    {
+      /* Address was not used before, nothing to do */
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : no change\n",
+           (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
+      return GNUNET_OK;
+    }
+    else if (GNUNET_YES == address->active)
+    {
+      /* Address was used before, disabling address */
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "%s %.2f : disabling address\n",
+           (1 == mlp_use) ? "[x]" : "[ ]", mlp_bw_out);
+      address->active = GNUNET_NO;
+      /* Set bandwidth to 0 */
+      address->assigned_bw_in = 0;
+      mlpi->b_in = 0;
+      address->assigned_bw_out = 0;
+      mlpi->b_out = 0;
+      return GNUNET_OK;
     }
+    else
+      GNUNET_break (0);
+  }
   else
-    GNUNET_break(0);
+    GNUNET_break (0);
 
   return GNUNET_OK;
 }
 
 
 static void
-notify(struct GAS_MLP_Handle *mlp,
-       enum GAS_Solver_Operation op,
-       enum GAS_Solver_Status stat,
-       enum GAS_Solver_Additional_Information add)
+notify (struct GAS_MLP_Handle *mlp,
+        enum GAS_Solver_Operation op,
+        enum GAS_Solver_Status stat,
+        enum GAS_Solver_Additional_Information add)
 {
-  mlp->env->info_cb(mlp->env->cls,
-                    op,
-                    stat,
-                    add);
+  mlp->env->info_cb (mlp->env->cls,
+                     op,
+                     stat,
+                     add);
 }
 
 
 static void
-mlp_branch_and_cut_cb(glp_tree *tree, void *info)
+mlp_branch_and_cut_cb (glp_tree *tree, void *info)
 {
   struct GAS_MLP_Handle *mlp = info;
   double mlp_obj = 0;
 
-  switch (glp_ios_reason(tree))
-    {
-    case GLP_ISELECT:
-      /* Do nothing here */
-      break;
+  switch (glp_ios_reason (tree))
+  {
+  case GLP_ISELECT:
+    /* Do nothing here */
+    break;
 
-    case GLP_IPREPRO:
-      /* Do nothing here */
-      break;
+  case GLP_IPREPRO:
+    /* Do nothing here */
+    break;
 
-    case GLP_IROWGEN:
-      /* Do nothing here */
-      break;
+  case GLP_IROWGEN:
+    /* Do nothing here */
+    break;
 
-    case GLP_IHEUR:
-      /* Do nothing here */
-      break;
+  case GLP_IHEUR:
+    /* Do nothing here */
+    break;
 
-    case GLP_ICUTGEN:
-      /* Do nothing here */
-      break;
+  case GLP_ICUTGEN:
+    /* Do nothing here */
+    break;
 
-    case GLP_IBRANCH:
-      /* Do nothing here */
-      break;
+  case GLP_IBRANCH:
+    /* Do nothing here */
+    break;
 
-    case GLP_IBINGO:
-      /* A better solution was found  */
-      mlp->ps.mlp_gap = glp_ios_mip_gap(tree);
-      mlp_obj = glp_mip_obj_val(mlp->p.prob);
-      mlp->ps.lp_mlp_gap = (abs(mlp_obj - mlp->ps.lp_objective_value)) / (abs(mlp_obj) + DBL_EPSILON);
-
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Found better integer solution, current gaps: %.3f <= %.3f, %.3f <= %.3f\n",
-          mlp->ps.mlp_gap, mlp->pv.mip_gap,
-          mlp->ps.lp_mlp_gap, mlp->pv.lp_mip_gap);
-
-      if (mlp->ps.mlp_gap <= mlp->pv.mip_gap)
-        {
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              "Current LP/MLP gap of %.3f smaller than tolerated gap of %.3f, terminating search\n",
-              mlp->ps.lp_mlp_gap, mlp->pv.lp_mip_gap);
-          glp_ios_terminate(tree);
-        }
-
-      if (mlp->ps.lp_mlp_gap <= mlp->pv.lp_mip_gap)
-        {
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              "Current LP/MLP gap of %.3f smaller than tolerated gap of %.3f, terminating search\n",
-              mlp->ps.lp_mlp_gap, mlp->pv.lp_mip_gap);
-          glp_ios_terminate(tree);
-        }
+  case GLP_IBINGO:
+    /* A better solution was found  */
+    mlp->ps.mlp_gap = glp_ios_mip_gap (tree);
+    mlp_obj = glp_mip_obj_val (mlp->p.prob);
+    mlp->ps.lp_mlp_gap = (abs (mlp_obj - mlp->ps.lp_objective_value)) / (abs (
+                                                                           mlp_obj)
+                                                                         +
+                                                                         DBL_EPSILON);
 
-      break;
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Found better integer solution, current gaps: %.3f <= %.3f, %.3f <= %.3f\n",
+         mlp->ps.mlp_gap, mlp->pv.mip_gap,
+         mlp->ps.lp_mlp_gap, mlp->pv.lp_mip_gap);
 
-    default:
-      break;
+    if (mlp->ps.mlp_gap <= mlp->pv.mip_gap)
+    {
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           "Current LP/MLP gap of %.3f smaller than tolerated gap of %.3f, terminating search\n",
+           mlp->ps.lp_mlp_gap, mlp->pv.lp_mip_gap);
+      glp_ios_terminate (tree);
     }
-  //GNUNET_break (0);
+
+    if (mlp->ps.lp_mlp_gap <= mlp->pv.lp_mip_gap)
+    {
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           "Current LP/MLP gap of %.3f smaller than tolerated gap of %.3f, terminating search\n",
+           mlp->ps.lp_mlp_gap, mlp->pv.lp_mip_gap);
+      glp_ios_terminate (tree);
+    }
+
+    break;
+
+  default:
+    break;
+  }
+  // GNUNET_break (0);
 }
 
 
@@ -1576,7 +1638,7 @@ mlp_branch_and_cut_cb(glp_tree *tree, void *info)
  * @return #GNUNET_OK if could be solved, #GNUNET_SYSERR on failure
  */
 static int
-GAS_mlp_solve_problem(void *solver)
+GAS_mlp_solve_problem (void *solver)
 {
   struct GAS_MLP_Handle *mlp = solver;
   char *filename;
@@ -1591,63 +1653,64 @@ GAS_mlp_solve_problem(void *solver)
   struct GNUNET_TIME_Relative dur_lp;
   struct GNUNET_TIME_Relative dur_mlp;
 
-  GNUNET_assert(NULL != solver);
+  GNUNET_assert (NULL != solver);
   dur_lp = GNUNET_TIME_UNIT_ZERO;
 
   if (GNUNET_YES == mlp->stat_bulk_lock)
-    {
-      mlp->stat_bulk_requests++;
-      return GNUNET_NO;
-    }
-  notify(mlp, GAS_OP_SOLVE_START, GAS_STAT_SUCCESS,
-         (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL : GAS_INFO_UPDATED);
-  start_total = GNUNET_TIME_absolute_get();
-
-  if (0 == GNUNET_CONTAINER_multipeermap_size(mlp->requested_peers))
-    {
-      notify(mlp, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_NONE);
-      return GNUNET_OK; /* No pending requests */
-    }
-  if (0 == GNUNET_CONTAINER_multipeermap_size(mlp->env->addresses))
-    {
-      notify(mlp, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_NONE);
-      return GNUNET_OK; /* No addresses available */
-    }
+  {
+    mlp->stat_bulk_requests++;
+    return GNUNET_NO;
+  }
+  notify (mlp, GAS_OP_SOLVE_START, GAS_STAT_SUCCESS,
+          (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL :
+          GAS_INFO_UPDATED);
+  start_total = GNUNET_TIME_absolute_get ();
+
+  if (0 == GNUNET_CONTAINER_multipeermap_size (mlp->requested_peers))
+  {
+    notify (mlp, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_NONE);
+    return GNUNET_OK;   /* No pending requests */
+  }
+  if (0 == GNUNET_CONTAINER_multipeermap_size (mlp->env->addresses))
+  {
+    notify (mlp, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_NONE);
+    return GNUNET_OK;   /* No addresses available */
+  }
 
   if ((GNUNET_NO == mlp->stat_mlp_prob_changed)
       && (GNUNET_NO == mlp->stat_mlp_prob_updated))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "No changes to problem\n");
+    notify (mlp, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_NONE);
+    return GNUNET_OK;
+  }
+  if (GNUNET_YES == mlp->stat_mlp_prob_changed)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Problem size changed, rebuilding\n");
+    notify (mlp, GAS_OP_SOLVE_SETUP_START, GAS_STAT_SUCCESS, GAS_INFO_FULL);
+    mlp_delete_problem (mlp);
+    if (GNUNET_SYSERR == mlp_create_problem (mlp))
     {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "No changes to problem\n");
-      notify(mlp, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_NONE);
-      return GNUNET_OK;
+      notify (mlp, GAS_OP_SOLVE_SETUP_STOP, GAS_STAT_FAIL, GAS_INFO_FULL);
+      return GNUNET_SYSERR;
     }
-  if (GNUNET_YES == mlp->stat_mlp_prob_changed)
+    notify (mlp, GAS_OP_SOLVE_SETUP_STOP, GAS_STAT_SUCCESS, GAS_INFO_FULL);
+    if (GNUNET_NO == mlp->opt_dbg_intopt_presolver)
     {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Problem size changed, rebuilding\n");
-      notify(mlp, GAS_OP_SOLVE_SETUP_START, GAS_STAT_SUCCESS, GAS_INFO_FULL);
-      mlp_delete_problem(mlp);
-      if (GNUNET_SYSERR == mlp_create_problem(mlp))
-        {
-          notify(mlp, GAS_OP_SOLVE_SETUP_STOP, GAS_STAT_FAIL, GAS_INFO_FULL);
-          return GNUNET_SYSERR;
-        }
-      notify(mlp, GAS_OP_SOLVE_SETUP_STOP, GAS_STAT_SUCCESS, GAS_INFO_FULL);
-      if (GNUNET_NO == mlp->opt_dbg_intopt_presolver)
-        {
-          mlp->control_param_lp.presolve = GLP_YES; /* LP presolver, we need lp solution */
-          mlp->control_param_mlp.presolve = GNUNET_NO; /* No presolver, we have LP solution */
-        }
-      else
-        {
-          mlp->control_param_lp.presolve = GNUNET_NO; /* LP presolver, we need lp solution */
-          mlp->control_param_mlp.presolve = GLP_YES; /* No presolver, we have LP solution */
-          dur_lp = GNUNET_TIME_UNIT_ZERO;
-        }
+      mlp->control_param_lp.presolve = GLP_YES;     /* LP presolver, we need lp solution */
+      mlp->control_param_mlp.presolve = GNUNET_NO;     /* No presolver, we have LP solution */
     }
-  else
+    else
     {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Problem was updated, resolving\n");
+      mlp->control_param_lp.presolve = GNUNET_NO;     /* LP presolver, we need lp solution */
+      mlp->control_param_mlp.presolve = GLP_YES;     /* No presolver, we have LP solution */
+      dur_lp = GNUNET_TIME_UNIT_ZERO;
     }
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Problem was updated, resolving\n");
+  }
 
   /* Reset solution info */
   mlp->ps.lp_objective_value = 0.0;
@@ -1655,224 +1718,238 @@ GAS_mlp_solve_problem(void *solver)
   mlp->ps.mlp_objective_value = 0.0;
   mlp->ps.lp_mlp_gap = 0.0;
 
-  dur_setup = GNUNET_TIME_absolute_get_duration(start_total);
+  dur_setup = GNUNET_TIME_absolute_get_duration (start_total);
 
   /* Run LP solver */
   if (GNUNET_NO == mlp->opt_dbg_intopt_presolver)
-    {
-      notify(mlp, GAS_OP_SOLVE_MLP_LP_START, GAS_STAT_SUCCESS,
-             (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL : GAS_INFO_UPDATED);
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Running LP solver %s\n",
-          (GLP_YES == mlp->control_param_lp.presolve) ? "with presolver" : "without presolver");
-      start_cur_op = GNUNET_TIME_absolute_get();
-
-      /* Solve LP */
-      /* Only for debugging:
-       * Always use LP presolver:
-       * mlp->control_param_lp.presolve = GLP_YES; */
-      res_lp = mlp_solve_lp_problem(mlp);
-      if (GNUNET_OK == res_lp)
-        {
-          mlp->ps.lp_objective_value = glp_get_obj_val(mlp->p.prob);
-          LOG(GNUNET_ERROR_TYPE_DEBUG,
-              "LP solution was: %.3f\n",
-              mlp->ps.lp_objective_value);
-        }
-
-      dur_lp = GNUNET_TIME_absolute_get_duration(start_cur_op);
-      notify(mlp, GAS_OP_SOLVE_MLP_LP_STOP,
-             (GNUNET_OK == res_lp) ? GAS_STAT_SUCCESS : GAS_STAT_FAIL,
-             (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL : GAS_INFO_UPDATED);
-    }
+  {
+    notify (mlp, GAS_OP_SOLVE_MLP_LP_START, GAS_STAT_SUCCESS,
+            (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL :
+            GAS_INFO_UPDATED);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Running LP solver %s\n",
+         (GLP_YES == mlp->control_param_lp.presolve) ? "with presolver" :
+         "without presolver");
+    start_cur_op = GNUNET_TIME_absolute_get ();
+
+    /* Solve LP */
+    /* Only for debugging:
+     * Always use LP presolver:
+     * mlp->control_param_lp.presolve = GLP_YES; */
+    res_lp = mlp_solve_lp_problem (mlp);
+    if (GNUNET_OK == res_lp)
+    {
+      mlp->ps.lp_objective_value = glp_get_obj_val (mlp->p.prob);
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "LP solution was: %.3f\n",
+           mlp->ps.lp_objective_value);
+    }
+
+    dur_lp = GNUNET_TIME_absolute_get_duration (start_cur_op);
+    notify (mlp, GAS_OP_SOLVE_MLP_LP_STOP,
+            (GNUNET_OK == res_lp) ? GAS_STAT_SUCCESS : GAS_STAT_FAIL,
+            (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL :
+            GAS_INFO_UPDATED);
+  }
 
   if (GNUNET_YES == mlp->opt_dbg_intopt_presolver)
     res_lp = GNUNET_OK;
 
   /* Run MLP solver */
   if ((GNUNET_OK == res_lp) || (GNUNET_YES == mlp->opt_dbg_intopt_presolver))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Running MLP solver \n");
+    notify (mlp, GAS_OP_SOLVE_MLP_MLP_START, GAS_STAT_SUCCESS,
+            (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL :
+            GAS_INFO_UPDATED);
+    start_cur_op = GNUNET_TIME_absolute_get ();
+
+    /* Solve MIP */
+
+    /* Only for debugging, always use LP presolver */
+    if (GNUNET_YES == mlp->opt_dbg_intopt_presolver)
+      mlp->control_param_mlp.presolve = GNUNET_YES;
+
+    mip_res = glp_intopt (mlp->p.prob, &mlp->control_param_mlp);
+    switch (mip_res)
     {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "Running MLP solver \n");
-      notify(mlp, GAS_OP_SOLVE_MLP_MLP_START, GAS_STAT_SUCCESS,
-             (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL : GAS_INFO_UPDATED);
-      start_cur_op = GNUNET_TIME_absolute_get();
-
-      /* Solve MIP */
-
-      /* Only for debugging, always use LP presolver */
-      if (GNUNET_YES == mlp->opt_dbg_intopt_presolver)
-        mlp->control_param_mlp.presolve = GNUNET_YES;
-
-      mip_res = glp_intopt(mlp->p.prob, &mlp->control_param_mlp);
-      switch (mip_res)
-        {
-        case 0:
-          /* Successful */
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              "Solving MLP problem: %s\n",
-              mlp_solve_to_string(mip_res));
-          break;
-
-        case GLP_ETMLIM: /* Time limit reached */
-        case GLP_EMIPGAP: /* MIP gap tolerance limit reached */
-        case GLP_ESTOP: /* Solver was instructed to stop*/
-          /* Semi-successful */
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              "Solving MLP problem solution was interupted: %s\n",
-              mlp_solve_to_string(mip_res));
-          break;
-
-        case GLP_EBOUND:
-        case GLP_EROOT:
-        case GLP_ENOPFS:
-        case GLP_ENODFS:
-        case GLP_EFAIL:
-        default:
-          /* Fail */
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              "Solving MLP problem failed: %s\n",
-              mlp_solve_to_string(mip_res));
-          break;
-        }
-
-      /* Analyze problem status  */
-      mip_status = glp_mip_status(mlp->p.prob);
-      switch (mip_status)
-        {
-        case GLP_OPT: /* solution is optimal */
-          LOG(GNUNET_ERROR_TYPE_WARNING,
-              "Solution of MLP problem is optimal: %s, %s\n",
-              mlp_solve_to_string(mip_res),
-              mlp_status_to_string(mip_status));
-          mip_res = GNUNET_OK;
-          break;
-
-        case GLP_FEAS: /* solution is feasible but not proven optimal */
-
-          if ((mlp->ps.mlp_gap <= mlp->pv.mip_gap) ||
-              (mlp->ps.lp_mlp_gap <= mlp->pv.lp_mip_gap))
-            {
-              LOG(GNUNET_ERROR_TYPE_INFO,
-                  "Solution of MLP problem is feasible and solution within gap constraints: %s, %s\n",
-                  mlp_solve_to_string(mip_res),
-                  mlp_status_to_string(mip_status));
-              mip_res = GNUNET_OK;
-            }
-          else
-            {
-              LOG(GNUNET_ERROR_TYPE_WARNING,
-                  "Solution of MLP problem is feasible but solution not within gap constraints: %s, %s\n",
-                  mlp_solve_to_string(mip_res),
-                  mlp_status_to_string(mip_status));
-              mip_res = GNUNET_SYSERR;
-            }
-          break;
-
-        case GLP_UNDEF: /* Solution undefined */
-        case GLP_NOFEAS: /* No feasible solution */
-        default:
-          LOG(GNUNET_ERROR_TYPE_ERROR,
-              "Solving MLP problem failed: %s %s\n",
-              mlp_solve_to_string(mip_res),
-              mlp_status_to_string(mip_status));
-          mip_res = GNUNET_SYSERR;
-          break;
-        }
-
-      dur_mlp = GNUNET_TIME_absolute_get_duration(start_cur_op);
-      dur_total = GNUNET_TIME_absolute_get_duration(start_total);
-
-      notify(mlp, GAS_OP_SOLVE_MLP_MLP_STOP,
-             (GNUNET_OK == mip_res) ? GAS_STAT_SUCCESS : GAS_STAT_FAIL,
-             (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL : GAS_INFO_UPDATED);
+    case 0:
+      /* Successful */
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           "Solving MLP problem: %s\n",
+           mlp_solve_to_string (mip_res));
+      break;
+
+    case GLP_ETMLIM:     /* Time limit reached */
+    case GLP_EMIPGAP:     /* MIP gap tolerance limit reached */
+    case GLP_ESTOP:     /* Solver was instructed to stop*/
+      /* Semi-successful */
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           "Solving MLP problem solution was interupted: %s\n",
+           mlp_solve_to_string (mip_res));
+      break;
+
+    case GLP_EBOUND:
+    case GLP_EROOT:
+    case GLP_ENOPFS:
+    case GLP_ENODFS:
+    case GLP_EFAIL:
+    default:
+      /* Fail */
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           "Solving MLP problem failed: %s\n",
+           mlp_solve_to_string (mip_res));
+      break;
     }
-  else
+
+    /* Analyze problem status  */
+    mip_status = glp_mip_status (mlp->p.prob);
+    switch (mip_status)
     {
-      /* Do not execute mip solver since lp solution is invalid */
-      dur_mlp = GNUNET_TIME_UNIT_ZERO;
-      dur_total = GNUNET_TIME_absolute_get_duration(start_total);
+    case GLP_OPT:     /* solution is optimal */
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Solution of MLP problem is optimal: %s, %s\n",
+           mlp_solve_to_string (mip_res),
+           mlp_status_to_string (mip_status));
+      mip_res = GNUNET_OK;
+      break;
+
+    case GLP_FEAS:     /* solution is feasible but not proven optimal */
+
+      if ((mlp->ps.mlp_gap <= mlp->pv.mip_gap) ||
+          (mlp->ps.lp_mlp_gap <= mlp->pv.lp_mip_gap))
+      {
+        LOG (GNUNET_ERROR_TYPE_INFO,
+             "Solution of MLP problem is feasible and solution within gap constraints: %s, %s\n",
+             mlp_solve_to_string (mip_res),
+             mlp_status_to_string (mip_status));
+        mip_res = GNUNET_OK;
+      }
+      else
+      {
+        LOG (GNUNET_ERROR_TYPE_WARNING,
+             "Solution of MLP problem is feasible but solution not within gap constraints: %s, %s\n",
+             mlp_solve_to_string (mip_res),
+             mlp_status_to_string (mip_status));
+        mip_res = GNUNET_SYSERR;
+      }
+      break;
 
-      notify(mlp, GAS_OP_SOLVE_MLP_MLP_STOP, GAS_STAT_FAIL,
-             (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL : GAS_INFO_UPDATED);
+    case GLP_UNDEF:     /* Solution undefined */
+    case GLP_NOFEAS:     /* No feasible solution */
+    default:
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Solving MLP problem failed: %s %s\n",
+           mlp_solve_to_string (mip_res),
+           mlp_status_to_string (mip_status));
       mip_res = GNUNET_SYSERR;
+      break;
     }
 
+    dur_mlp = GNUNET_TIME_absolute_get_duration (start_cur_op);
+    dur_total = GNUNET_TIME_absolute_get_duration (start_total);
+
+    notify (mlp, GAS_OP_SOLVE_MLP_MLP_STOP,
+            (GNUNET_OK == mip_res) ? GAS_STAT_SUCCESS : GAS_STAT_FAIL,
+            (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL :
+            GAS_INFO_UPDATED);
+  }
+  else
+  {
+    /* Do not execute mip solver since lp solution is invalid */
+    dur_mlp = GNUNET_TIME_UNIT_ZERO;
+    dur_total = GNUNET_TIME_absolute_get_duration (start_total);
+
+    notify (mlp, GAS_OP_SOLVE_MLP_MLP_STOP, GAS_STAT_FAIL,
+            (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL :
+            GAS_INFO_UPDATED);
+    mip_res = GNUNET_SYSERR;
+  }
+
   /* Notify about end */
-  notify(mlp, GAS_OP_SOLVE_STOP,
-         ((GNUNET_OK == mip_res) && (GNUNET_OK == mip_res)) ? GAS_STAT_SUCCESS : GAS_STAT_FAIL,
-         (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL : GAS_INFO_UPDATED);
-
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Execution time for %s solve: (total/setup/lp/mlp) : %llu %llu %llu %llu\n",
-      (GNUNET_YES == mlp->stat_mlp_prob_changed) ? "full" : "updated",
-      (unsigned long long)dur_total.rel_value_us,
-      (unsigned long long)dur_setup.rel_value_us,
-      (unsigned long long)dur_lp.rel_value_us,
-      (unsigned long long)dur_mlp.rel_value_us);
+  notify (mlp, GAS_OP_SOLVE_STOP,
+          ((GNUNET_OK == mip_res) && (GNUNET_OK == mip_res)) ?
+          GAS_STAT_SUCCESS : GAS_STAT_FAIL,
+          (GNUNET_YES == mlp->stat_mlp_prob_changed) ? GAS_INFO_FULL :
+          GAS_INFO_UPDATED);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Execution time for %s solve: (total/setup/lp/mlp) : %llu %llu %llu %llu\n",
+       (GNUNET_YES == mlp->stat_mlp_prob_changed) ? "full" : "updated",
+       (unsigned long long) dur_total.rel_value_us,
+       (unsigned long long) dur_setup.rel_value_us,
+       (unsigned long long) dur_lp.rel_value_us,
+       (unsigned long long) dur_mlp.rel_value_us);
 
   /* Save stats */
   mlp->ps.lp_res = res_lp;
   mlp->ps.mip_res = mip_res;
   mlp->ps.lp_presolv = mlp->control_param_lp.presolve;
   mlp->ps.mip_presolv = mlp->control_param_mlp.presolve;
-  mlp->ps.p_cols = glp_get_num_cols(mlp->p.prob);
-  mlp->ps.p_rows = glp_get_num_rows(mlp->p.prob);
+  mlp->ps.p_cols = glp_get_num_cols (mlp->p.prob);
+  mlp->ps.p_rows = glp_get_num_rows (mlp->p.prob);
   mlp->ps.p_elements = mlp->p.num_elements;
 
   /* Propagate result*/
-  notify(mlp, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
-         (GNUNET_OK == res_lp) && (GNUNET_OK == mip_res) ? GAS_STAT_SUCCESS : GAS_STAT_FAIL,
-         GAS_INFO_NONE);
+  notify (mlp, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
+          (GNUNET_OK == res_lp) && (GNUNET_OK == mip_res) ? GAS_STAT_SUCCESS :
+          GAS_STAT_FAIL,
+          GAS_INFO_NONE);
   if ((GNUNET_OK == res_lp) && (GNUNET_OK == mip_res))
-    {
-      GNUNET_CONTAINER_multipeermap_iterate(mlp->env->addresses,
-                                            &mlp_propagate_results, mlp);
-    }
-  notify(mlp, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
-         (GNUNET_OK == res_lp) && (GNUNET_OK == mip_res) ? GAS_STAT_SUCCESS : GAS_STAT_FAIL,
-         GAS_INFO_NONE);
-
-  struct GNUNET_TIME_Absolute time = GNUNET_TIME_absolute_get();
+  {
+    GNUNET_CONTAINER_multipeermap_iterate (mlp->env->addresses,
+                                           &mlp_propagate_results, mlp);
+  }
+  notify (mlp, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
+          (GNUNET_OK == res_lp) && (GNUNET_OK == mip_res) ? GAS_STAT_SUCCESS :
+          GAS_STAT_FAIL,
+          GAS_INFO_NONE);
+
+  struct GNUNET_TIME_Absolute time = GNUNET_TIME_absolute_get ();
   if ((GNUNET_YES == mlp->opt_dump_problem_all) ||
-      (mlp->opt_dump_problem_on_fail && ((GNUNET_OK != res_lp) || (GNUNET_OK != mip_res))))
-    {
-      /* Write problem to disk */
-      switch (mlp->opt_log_format)
-        {
-        case MLP_CPLEX:
-          GNUNET_asprintf(&filename, "problem_p_%u_a%u_%llu.cplex", mlp->p.num_peers,
-                          mlp->p.num_addresses, time.abs_value_us);
-          glp_write_lp(mlp->p.prob, NULL, filename);
-          break;
-
-        case MLP_GLPK:
-          GNUNET_asprintf(&filename, "problem_p_%u_a%u_%llu.glpk", mlp->p.num_peers,
-                          mlp->p.num_addresses, time.abs_value_us);
-          glp_write_prob(mlp->p.prob, 0, filename);
-          break;
-
-        case MLP_MPS:
-          GNUNET_asprintf(&filename, "problem_p_%u_a%u_%llu.mps", mlp->p.num_peers,
-                          mlp->p.num_addresses, time.abs_value_us);
-          glp_write_mps(mlp->p.prob, GLP_MPS_FILE, NULL, filename);
-          break;
-
-        default:
-          break;
-        }
-      LOG(GNUNET_ERROR_TYPE_ERROR, "Dumped problem to file: `%s' \n", filename);
-      GNUNET_free(filename);
+      (mlp->opt_dump_problem_on_fail && ((GNUNET_OK != res_lp) || (GNUNET_OK !=
+                                                                   mip_res))))
+  {
+    /* Write problem to disk */
+    switch (mlp->opt_log_format)
+    {
+    case MLP_CPLEX:
+      GNUNET_asprintf (&filename, "problem_p_%u_a%u_%llu.cplex",
+                       mlp->p.num_peers,
+                       mlp->p.num_addresses, time.abs_value_us);
+      glp_write_lp (mlp->p.prob, NULL, filename);
+      break;
+
+    case MLP_GLPK:
+      GNUNET_asprintf (&filename, "problem_p_%u_a%u_%llu.glpk",
+                       mlp->p.num_peers,
+                       mlp->p.num_addresses, time.abs_value_us);
+      glp_write_prob (mlp->p.prob, 0, filename);
+      break;
+
+    case MLP_MPS:
+      GNUNET_asprintf (&filename, "problem_p_%u_a%u_%llu.mps", mlp->p.num_peers,
+                       mlp->p.num_addresses, time.abs_value_us);
+      glp_write_mps (mlp->p.prob, GLP_MPS_FILE, NULL, filename);
+      break;
+
+    default:
+      break;
     }
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Dumped problem to file: `%s' \n", filename);
+    GNUNET_free (filename);
+  }
   if ((mlp->opt_dump_solution_all) ||
-      (mlp->opt_dump_solution_on_fail && ((GNUNET_OK != res_lp) || (GNUNET_OK != mip_res))))
-    {
-      /* Write solution to disk */
-      GNUNET_asprintf(&filename, "problem_p_%u_a%u_%llu.sol", mlp->p.num_peers,
-                      mlp->p.num_addresses, time.abs_value_us);
-      glp_print_mip(mlp->p.prob, filename);
-      LOG(GNUNET_ERROR_TYPE_ERROR, "Dumped solution to file: `%s' \n", filename);
-      GNUNET_free(filename);
-    }
+      (mlp->opt_dump_solution_on_fail && ((GNUNET_OK != res_lp) || (GNUNET_OK !=
+                                                                    mip_res))))
+  {
+    /* Write solution to disk */
+    GNUNET_asprintf (&filename, "problem_p_%u_a%u_%llu.sol", mlp->p.num_peers,
+                     mlp->p.num_addresses, time.abs_value_us);
+    glp_print_mip (mlp->p.prob, filename);
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Dumped solution to file: `%s' \n", filename);
+    GNUNET_free (filename);
+  }
 
   /* Reset change and update marker */
   mlp->control_param_lp.presolve = GLP_NO;
@@ -1893,46 +1970,46 @@ GAS_mlp_solve_problem(void *solver)
  * @param network network type of this address
  */
 static void
-GAS_mlp_address_add(void *solver,
-                    struct ATS_Address *address,
-                    uint32_t network)
+GAS_mlp_address_add (void *solver,
+                     struct ATS_Address *address,
+                     uint32_t network)
 {
   struct GAS_MLP_Handle *mlp = solver;
 
   if (GNUNET_NT_COUNT <= network)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
 
   if (NULL == address->solver_information)
-    {
-      address->solver_information = GNUNET_new(struct MLP_information);
-    }
+  {
+    address->solver_information = GNUNET_new (struct MLP_information);
+  }
   else
-    LOG(GNUNET_ERROR_TYPE_ERROR,
-        _("Adding address for peer `%s' multiple times\n"),
-        GNUNET_i2s(&address->peer));
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("Adding address for peer `%s' multiple times\n"),
+         GNUNET_i2s (&address->peer));
 
   /* Is this peer included in the problem? */
   if (NULL ==
-      GNUNET_CONTAINER_multipeermap_get(mlp->requested_peers,
-                                        &address->peer))
-    {
-      /* FIXME: should this be an error? */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Adding address for peer `%s' without address request\n",
-          GNUNET_i2s(&address->peer));
-      return;
-    }
+      GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers,
+                                         &address->peer))
+  {
+    /* FIXME: should this be an error? */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Adding address for peer `%s' without address request\n",
+         GNUNET_i2s (&address->peer));
+    return;
+  }
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Adding address for peer `%s' with address request \n",
-      GNUNET_i2s(&address->peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding address for peer `%s' with address request \n",
+       GNUNET_i2s (&address->peer));
   /* Problem size changed: new address for peer with pending request */
   mlp->stat_mlp_prob_changed = GNUNET_YES;
   if (GNUNET_YES == mlp->opt_mlp_auto_solve)
-    GAS_mlp_solve_problem(solver);
+    GAS_mlp_solve_problem (solver);
 }
 
 
@@ -1943,8 +2020,8 @@ GAS_mlp_address_add(void *solver,
  * @param address the address
  */
 static void
-GAS_mlp_address_property_changed(void *solver,
-                                 struct ATS_Address *address)
+GAS_mlp_address_property_changed (void *solver,
+                                  struct ATS_Address *address)
 {
   struct MLP_information *mlpi = address->solver_information;
   struct GAS_MLP_Handle *mlp = solver;
@@ -1953,46 +2030,46 @@ GAS_mlp_address_property_changed(void *solver,
     return; /* There is no MLP problem to update yet */
 
   if (NULL == mlpi)
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          _("Updating address property for peer `%s' %p not added before\n"),
-          GNUNET_i2s(&address->peer),
-          address);
-      GNUNET_break(0);
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         _ ("Updating address property for peer `%s' %p not added before\n"),
+         GNUNET_i2s (&address->peer),
+         address);
+    GNUNET_break (0);
+    return;
+  }
   if (NULL ==
-      GNUNET_CONTAINER_multipeermap_get(mlp->requested_peers,
-                                        &address->peer))
-    {
-      /* Peer is not requested, so no need to update problem */
-      return;
-    }
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Updating properties for peer `%s'\n",
-      GNUNET_i2s(&address->peer));
+      GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers,
+                                         &address->peer))
+  {
+    /* Peer is not requested, so no need to update problem */
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Updating properties for peer `%s'\n",
+       GNUNET_i2s (&address->peer));
 
   if (GNUNET_YES == mlp->opt_dbg_feasibility_only)
     return;
 
   /* Update c7) [r_q[index]][c_b] = f_q * q_averaged[type_index] */
   if ((GNUNET_YES ==
-       mlp_create_problem_update_value(&mlp->p,
-                                       mlp->p.r_q[RQ_QUALITY_METRIC_DELAY],
-                                       mlpi->c_b,
-                                       address->norm_delay.norm,
-                                       __LINE__)) ||
+       mlp_create_problem_update_value (&mlp->p,
+                                        mlp->p.r_q[RQ_QUALITY_METRIC_DELAY],
+                                        mlpi->c_b,
+                                        address->norm_delay.norm,
+                                        __LINE__)) ||
       (GNUNET_YES ==
-       mlp_create_problem_update_value(&mlp->p,
-                                       mlp->p.r_q[RQ_QUALITY_METRIC_DISTANCE],
-                                       mlpi->c_b,
-                                       address->norm_distance.norm,
-                                       __LINE__)))
-    {
-      mlp->stat_mlp_prob_updated = GNUNET_YES;
-      if (GNUNET_YES == mlp->opt_mlp_auto_solve)
-        GAS_mlp_solve_problem(solver);
-    }
+       mlp_create_problem_update_value (&mlp->p,
+                                        mlp->p.r_q[RQ_QUALITY_METRIC_DISTANCE],
+                                        mlpi->c_b,
+                                        address->norm_distance.norm,
+                                        __LINE__)))
+  {
+    mlp->stat_mlp_prob_updated = GNUNET_YES;
+    if (GNUNET_YES == mlp->opt_mlp_auto_solve)
+      GAS_mlp_solve_problem (solver);
+  }
 }
 
 
@@ -2004,9 +2081,9 @@ GAS_mlp_address_property_changed(void *solver,
  * @return #GNUNET_OK
  */
 static int
-mlp_get_preferred_address_it(void *cls,
-                             const struct GNUNET_PeerIdentity *key,
-                             void *value)
+mlp_get_preferred_address_it (void *cls,
+                              const struct GNUNET_PeerIdentity *key,
+                              void *value)
 {
   static int counter = 0;
   struct ATS_Address **aa = cls;
@@ -2026,40 +2103,40 @@ mlp_get_preferred_address_it(void *cls,
    */
 
   if (GNUNET_YES == mlpi->n)
-    {
-      (*aa) = addr;
-      (*aa)->assigned_bw_in = mlpi->b_in;
-      (*aa)->assigned_bw_out = mlpi->b_out;
-      return GNUNET_NO;
-    }
+  {
+    (*aa) = addr;
+    (*aa)->assigned_bw_in = mlpi->b_in;
+    (*aa)->assigned_bw_out = mlpi->b_out;
+    return GNUNET_NO;
+  }
   counter++;
   return GNUNET_YES;
 }
 
 
 static double
-get_peer_pref_value(struct GAS_MLP_Handle *mlp,
-                    const struct GNUNET_PeerIdentity *peer)
+get_peer_pref_value (struct GAS_MLP_Handle *mlp,
+                     const struct GNUNET_PeerIdentity *peer)
 {
   double res;
   const double *preferences;
   int c;
 
-  preferences = mlp->env->get_preferences(mlp->env->cls, peer);
+  preferences = mlp->env->get_preferences (mlp->env->cls, peer);
   res = 0.0;
   for (c = 0; c < GNUNET_ATS_PREFERENCE_END; c++)
-    {
-      /* fprintf (stderr, "VALUE[%u] %s %.3f \n",
-       *        c, GNUNET_i2s (&cur->addr->peer), t[c]); */
-      res += preferences[c];
-    }
+  {
+    /* fprintf (stderr, "VALUE[%u] %s %.3f \n",
+     *        c, GNUNET_i2s (&cur->addr->peer), t[c]); */
+    res += preferences[c];
+  }
 
   res /= GNUNET_ATS_PREFERENCE_END;
   res += 1.0;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Peer preference for peer  `%s' == %.2f\n",
-      GNUNET_i2s(peer), res);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer preference for peer  `%s' == %.2f\n",
+       GNUNET_i2s (peer), res);
 
   return res;
 }
@@ -2072,51 +2149,54 @@ get_peer_pref_value(struct GAS_MLP_Handle *mlp,
  * @param peer the peer
  */
 static void
-GAS_mlp_get_preferred_address(void *solver,
-                              const struct GNUNET_PeerIdentity *peer)
+GAS_mlp_get_preferred_address (void *solver,
+                               const struct GNUNET_PeerIdentity *peer)
 {
   struct GAS_MLP_Handle *mlp = solver;
   struct ATS_Peer *p;
   struct ATS_Address *res;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Getting preferred address for `%s'\n",
-      GNUNET_i2s(peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Getting preferred address for `%s'\n",
+       GNUNET_i2s (peer));
 
   /* Is this peer included in the problem? */
   if (NULL ==
-      GNUNET_CONTAINER_multipeermap_get(mlp->requested_peers,
-                                        peer))
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO, "Adding peer `%s' to list of requested_peers with requests\n",
-          GNUNET_i2s(peer));
-
-      p = GNUNET_new(struct ATS_Peer);
-      p->id = (*peer);
-      p->f = get_peer_pref_value(mlp, peer);
-      GNUNET_CONTAINER_multipeermap_put(mlp->requested_peers,
-                                        peer, p,
-                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-
-      /* Added new peer, we have to rebuild problem before solving */
-      mlp->stat_mlp_prob_changed = GNUNET_YES;
-
-      if ((GNUNET_YES == mlp->opt_mlp_auto_solve) &&
-          (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(mlp->env->addresses,
-                                                                peer)))
-        {
-          mlp->exclude_peer = peer;
-          GAS_mlp_solve_problem(mlp);
-          mlp->exclude_peer = NULL;
-        }
-    }
+      GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers,
+                                         peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Adding peer `%s' to list of requested_peers with requests\n",
+         GNUNET_i2s (peer));
+
+    p = GNUNET_new (struct ATS_Peer);
+    p->id = (*peer);
+    p->f = get_peer_pref_value (mlp, peer);
+    GNUNET_CONTAINER_multipeermap_put (mlp->requested_peers,
+                                       peer, p,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+
+    /* Added new peer, we have to rebuild problem before solving */
+    mlp->stat_mlp_prob_changed = GNUNET_YES;
+
+    if ((GNUNET_YES == mlp->opt_mlp_auto_solve) &&
+        (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (
+           mlp->env->addresses,
+           peer)))
+    {
+      mlp->exclude_peer = peer;
+      GAS_mlp_solve_problem (mlp);
+      mlp->exclude_peer = NULL;
+    }
+  }
   /* Get prefered address */
   res = NULL;
-  GNUNET_CONTAINER_multipeermap_get_multiple(mlp->env->addresses, peer,
-                                             &mlp_get_preferred_address_it, &res);
+  GNUNET_CONTAINER_multipeermap_get_multiple (mlp->env->addresses, peer,
+                                              &mlp_get_preferred_address_it,
+                                              &res);
   if (NULL != res)
-    mlp->env->bandwidth_changed_cb(mlp->env->cls,
-                                   res);
+    mlp->env->bandwidth_changed_cb (mlp->env->cls,
+                                    res);
 }
 
 
@@ -2129,8 +2209,8 @@ GAS_mlp_get_preferred_address(void *solver,
  * @param address the address to delete
  */
 static void
-GAS_mlp_address_delete(void *solver,
-                       struct ATS_Address *address)
+GAS_mlp_address_delete (void *solver,
+                        struct ATS_Address *address)
 {
   struct GAS_MLP_Handle *mlp = solver;
   struct MLP_information *mlpi;
@@ -2139,11 +2219,11 @@ GAS_mlp_address_delete(void *solver,
 
   mlpi = address->solver_information;
   if (NULL != mlpi)
-    {
-      /* Remove full address */
-      GNUNET_free(mlpi);
-      address->solver_information = NULL;
-    }
+  {
+    /* Remove full address */
+    GNUNET_free (mlpi);
+    address->solver_information = NULL;
+  }
   was_active = address->active;
   address->active = GNUNET_NO;
   address->assigned_bw_in = 0;
@@ -2151,38 +2231,38 @@ GAS_mlp_address_delete(void *solver,
 
   /* Is this peer included in the problem? */
   if (NULL ==
-      GNUNET_CONTAINER_multipeermap_get(mlp->requested_peers,
-                                        &address->peer))
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Deleting address for peer `%s' without address request \n",
-          GNUNET_i2s(&address->peer));
-      return;
-    }
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "Deleting address for peer `%s' with address request \n",
-      GNUNET_i2s(&address->peer));
+      GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers,
+                                         &address->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Deleting address for peer `%s' without address request \n",
+         GNUNET_i2s (&address->peer));
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Deleting address for peer `%s' with address request \n",
+       GNUNET_i2s (&address->peer));
 
   /* Problem size changed: new address for peer with pending request */
   mlp->stat_mlp_prob_changed = GNUNET_YES;
   if (GNUNET_YES == mlp->opt_mlp_auto_solve)
-    {
-      GAS_mlp_solve_problem(solver);
-    }
+  {
+    GAS_mlp_solve_problem (solver);
+  }
   if (GNUNET_YES == was_active)
-    {
-      GAS_mlp_get_preferred_address(solver, &address->peer);
-      res = NULL;
-      GNUNET_CONTAINER_multipeermap_get_multiple(mlp->env->addresses,
-                                                 &address->peer,
-                                                 &mlp_get_preferred_address_it,
-                                                 &res);
-      if (NULL == res)
-        {
-          /* No alternative address, disconnecting peer */
-          mlp->env->bandwidth_changed_cb(mlp->env->cls, address);
-        }
-    }
+  {
+    GAS_mlp_get_preferred_address (solver, &address->peer);
+    res = NULL;
+    GNUNET_CONTAINER_multipeermap_get_multiple (mlp->env->addresses,
+                                                &address->peer,
+                                                &mlp_get_preferred_address_it,
+                                                &res);
+    if (NULL == res)
+    {
+      /* No alternative address, disconnecting peer */
+      mlp->env->bandwidth_changed_cb (mlp->env->cls, address);
+    }
+  }
 }
 
 
@@ -2192,38 +2272,38 @@ GAS_mlp_address_delete(void *solver,
  * @param solver the solver
  */
 static void
-GAS_mlp_bulk_start(void *solver)
+GAS_mlp_bulk_start (void *solver)
 {
   struct GAS_MLP_Handle *s = solver;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Locking solver for bulk operation ...\n");
-  GNUNET_assert(NULL != solver);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Locking solver for bulk operation ...\n");
+  GNUNET_assert (NULL != solver);
   s->stat_bulk_lock++;
 }
 
 
 static void
-GAS_mlp_bulk_stop(void *solver)
+GAS_mlp_bulk_stop (void *solver)
 {
   struct GAS_MLP_Handle *s = solver;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Unlocking solver from bulk operation ...\n");
-  GNUNET_assert(NULL != solver);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Unlocking solver from bulk operation ...\n");
+  GNUNET_assert (NULL != solver);
 
   if (s->stat_bulk_lock < 1)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   s->stat_bulk_lock--;
 
   if (0 < s->stat_bulk_requests)
-    {
-      GAS_mlp_solve_problem(solver);
-      s->stat_bulk_requests = 0;
-    }
+  {
+    GAS_mlp_solve_problem (solver);
+    s->stat_bulk_requests = 0;
+  }
 }
 
 
@@ -2235,26 +2315,28 @@ GAS_mlp_bulk_stop(void *solver)
  * @param peer the peer
  */
 static void
-GAS_mlp_stop_get_preferred_address(void *solver,
-                                   const struct GNUNET_PeerIdentity *peer)
+GAS_mlp_stop_get_preferred_address (void *solver,
+                                    const struct GNUNET_PeerIdentity *peer)
 {
   struct GAS_MLP_Handle *mlp = solver;
   struct ATS_Peer *p = NULL;
 
-  GNUNET_assert(NULL != solver);
-  GNUNET_assert(NULL != peer);
-  if (NULL != (p = GNUNET_CONTAINER_multipeermap_get(mlp->requested_peers, peer)))
+  GNUNET_assert (NULL != solver);
+  GNUNET_assert (NULL != peer);
+  if (NULL != (p = GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers,
+                                                      peer)))
+  {
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_remove (mlp->requested_peers,
+                                                         peer, p));
+    GNUNET_free (p);
+
+    mlp->stat_mlp_prob_changed = GNUNET_YES;
+    if (GNUNET_YES == mlp->opt_mlp_auto_solve)
     {
-      GNUNET_assert(GNUNET_YES ==
-                    GNUNET_CONTAINER_multipeermap_remove(mlp->requested_peers, peer, p));
-      GNUNET_free(p);
-
-      mlp->stat_mlp_prob_changed = GNUNET_YES;
-      if (GNUNET_YES == mlp->opt_mlp_auto_solve)
-        {
-          GAS_mlp_solve_problem(solver);
-        }
+      GAS_mlp_solve_problem (solver);
     }
+  }
 }
 
 
@@ -2267,48 +2349,49 @@ GAS_mlp_stop_get_preferred_address(void *solver,
  * @param pref_rel the relative score
  */
 static void
-GAS_mlp_address_change_preference(void *solver,
-                                  const struct GNUNET_PeerIdentity *peer,
-                                  enum GNUNET_ATS_PreferenceKind kind,
-                                  double pref_rel)
+GAS_mlp_address_change_preference (void *solver,
+                                   const struct GNUNET_PeerIdentity *peer,
+                                   enum GNUNET_ATS_PreferenceKind kind,
+                                   double pref_rel)
 {
   struct GAS_MLP_Handle *mlp = solver;
   struct ATS_Peer *p;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Changing preference for address for peer `%s' to %.2f\n",
-      GNUNET_i2s(peer),
-      pref_rel);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Changing preference for address for peer `%s' to %.2f\n",
+       GNUNET_i2s (peer),
+       pref_rel);
 
-  GNUNET_STATISTICS_update(mlp->env->stats,
-                           "# LP address preference changes", 1, GNUNET_NO);
+  GNUNET_STATISTICS_update (mlp->env->stats,
+                            "# LP address preference changes", 1, GNUNET_NO);
   /* Update the constraints with changed preferences */
 
 
 
   /* Update relativity constraint c9 */
-  if (NULL == (p = GNUNET_CONTAINER_multipeermap_get(mlp->requested_peers, peer)))
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Updating preference for unknown peer `%s'\n",
-          GNUNET_i2s(peer));
-      return;
-    }
+  if (NULL == (p = GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers,
+                                                      peer)))
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Updating preference for unknown peer `%s'\n",
+         GNUNET_i2s (peer));
+    return;
+  }
 
   if (GNUNET_NO == mlp->opt_dbg_feasibility_only)
-    {
-      p->f = get_peer_pref_value(mlp, peer);
-      mlp_create_problem_update_value(&mlp->p,
-                                      p->r_c9,
-                                      mlp->p.c_r,
-                                      -p->f,
-                                      __LINE__);
-
-      /* Problem size changed: new address for peer with pending request */
-      mlp->stat_mlp_prob_updated = GNUNET_YES;
-      if (GNUNET_YES == mlp->opt_mlp_auto_solve)
-        GAS_mlp_solve_problem(solver);
-    }
+  {
+    p->f = get_peer_pref_value (mlp, peer);
+    mlp_create_problem_update_value (&mlp->p,
+                                     p->r_c9,
+                                     mlp->p.c_r,
+                                     -p->f,
+                                     __LINE__);
+
+    /* Problem size changed: new address for peer with pending request */
+    mlp->stat_mlp_prob_updated = GNUNET_YES;
+    if (GNUNET_YES == mlp->opt_mlp_auto_solve)
+      GAS_mlp_solve_problem (solver);
+  }
 }
 
 
@@ -2323,31 +2406,31 @@ GAS_mlp_address_change_preference(void *solver,
  * @param score the score
  */
 static void
-GAS_mlp_address_preference_feedback(void *solver,
-                                    struct GNUNET_SERVICE_Client *application,
-                                    const struct GNUNET_PeerIdentity *peer,
-                                    const struct GNUNET_TIME_Relative scope,
-                                    enum GNUNET_ATS_PreferenceKind kind,
-                                    double score)
+GAS_mlp_address_preference_feedback (void *solver,
+                                     struct GNUNET_SERVICE_Client *application,
+                                     const struct GNUNET_PeerIdentity *peer,
+                                     const struct GNUNET_TIME_Relative scope,
+                                     enum GNUNET_ATS_PreferenceKind kind,
+                                     double score)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
 
-  GNUNET_assert(NULL != solver);
-  GNUNET_assert(NULL != peer);
-  GNUNET_assert(NULL != s);
+  GNUNET_assert (NULL != solver);
+  GNUNET_assert (NULL != peer);
+  GNUNET_assert (NULL != s);
 }
 
 
 static int
-mlp_free_peers(void *cls,
-               const struct GNUNET_PeerIdentity *key, void *value)
+mlp_free_peers (void *cls,
+                const struct GNUNET_PeerIdentity *key, void *value)
 {
   struct GNUNET_CONTAINER_MultiPeerMap *map = cls;
   struct ATS_Peer *p = value;
 
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(map, key, value));
-  GNUNET_free(p);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (map, key, value));
+  GNUNET_free (p);
 
   return GNUNET_OK;
 }
@@ -2360,36 +2443,36 @@ mlp_free_peers(void *cls,
  * @return NULL
  */
 void *
-libgnunet_plugin_ats_mlp_done(void *cls)
+libgnunet_plugin_ats_mlp_done (void *cls)
 {
   struct GNUNET_ATS_SolverFunctions *sf = cls;
   struct GAS_MLP_Handle *mlp = sf->cls;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Shutting down mlp solver\n");
-  mlp_delete_problem(mlp);
-  GNUNET_CONTAINER_multipeermap_iterate(mlp->requested_peers,
-                                        &mlp_free_peers,
-                                        mlp->requested_peers);
-  GNUNET_CONTAINER_multipeermap_destroy(mlp->requested_peers);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutting down mlp solver\n");
+  mlp_delete_problem (mlp);
+  GNUNET_CONTAINER_multipeermap_iterate (mlp->requested_peers,
+                                         &mlp_free_peers,
+                                         mlp->requested_peers);
+  GNUNET_CONTAINER_multipeermap_destroy (mlp->requested_peers);
   mlp->requested_peers = NULL;
 
   /* Clean up GLPK environment */
-  glp_free_env();
-  GNUNET_free(mlp);
+  glp_free_env ();
+  GNUNET_free (mlp);
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Shutdown down of mlp solver complete\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutdown down of mlp solver complete\n");
   return NULL;
 }
 
 
 void *
-libgnunet_plugin_ats_mlp_init(void *cls)
+libgnunet_plugin_ats_mlp_init (void *cls)
 {
   static struct GNUNET_ATS_SolverFunctions sf;
   struct GNUNET_ATS_PluginEnvironment *env = cls;
-  struct GAS_MLP_Handle * mlp = GNUNET_new(struct GAS_MLP_Handle);
+  struct GAS_MLP_Handle *mlp = GNUNET_new (struct GAS_MLP_Handle);
   float f_tmp;
   unsigned long long tmp;
   unsigned int b_min;
@@ -2401,356 +2484,391 @@ libgnunet_plugin_ats_mlp_init(void *cls)
   long long unsigned int max_iterations;
 
   /* Init GLPK environment */
-  int res = glp_init_env();
+  int res = glp_init_env ();
 
   switch (res)
-    {
-    case 0:
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
-          "initialization successful");
-      break;
-
-    case 1:
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
-          "environment is already initialized");
-      break;
-
-    case 2:
-      LOG(GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
-          "initialization failed (insufficient memory)");
-      GNUNET_free(mlp);
-      return NULL;
-      break;
-
-    case 3:
-      LOG(GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
-          "initialization failed (unsupported programming model)");
-      GNUNET_free(mlp);
-      return NULL;
-      break;
-
-    default:
-      break;
-    }
-
-  mlp->opt_dump_problem_all = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                   "ats", "MLP_DUMP_PROBLEM_ALL");
+  {
+  case 0:
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
+         "initialization successful");
+    break;
+
+  case 1:
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
+         "environment is already initialized");
+    break;
+
+  case 2:
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
+         "initialization failed (insufficient memory)");
+    GNUNET_free (mlp);
+    return NULL;
+    break;
+
+  case 3:
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
+         "initialization failed (unsupported programming model)");
+    GNUNET_free (mlp);
+    return NULL;
+    break;
+
+  default:
+    break;
+  }
+
+  mlp->opt_dump_problem_all = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                                    "ats",
+                                                                    "MLP_DUMP_PROBLEM_ALL");
   if (GNUNET_SYSERR == mlp->opt_dump_problem_all)
     mlp->opt_dump_problem_all = GNUNET_NO;
 
-  mlp->opt_dump_solution_all = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                    "ats", "MLP_DUMP_SOLUTION_ALL");
+  mlp->opt_dump_solution_all = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                                     "ats",
+                                                                     "MLP_DUMP_SOLUTION_ALL");
   if (GNUNET_SYSERR == mlp->opt_dump_solution_all)
     mlp->opt_dump_solution_all = GNUNET_NO;
 
-  mlp->opt_dump_problem_on_fail = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                       "ats", "MLP_DUMP_PROBLEM_ON_FAIL");
+  mlp->opt_dump_problem_on_fail = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DUMP_PROBLEM_ON_FAIL");
   if (GNUNET_SYSERR == mlp->opt_dump_problem_on_fail)
     mlp->opt_dump_problem_on_fail = GNUNET_NO;
 
-  mlp->opt_dump_solution_on_fail = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                        "ats", "MLP_DUMP_SOLUTION_ON_FAIL");
+  mlp->opt_dump_solution_on_fail = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DUMP_SOLUTION_ON_FAIL");
   if (GNUNET_SYSERR == mlp->opt_dump_solution_on_fail)
     mlp->opt_dump_solution_on_fail = GNUNET_NO;
 
-  mlp->opt_dbg_glpk_verbose = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                   "ats", "MLP_DBG_GLPK_VERBOSE");
+  mlp->opt_dbg_glpk_verbose = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                                    "ats",
+                                                                    "MLP_DBG_GLPK_VERBOSE");
   if (GNUNET_SYSERR == mlp->opt_dbg_glpk_verbose)
     mlp->opt_dbg_glpk_verbose = GNUNET_NO;
 
-  mlp->opt_dbg_feasibility_only = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                       "ats", "MLP_DBG_FEASIBILITY_ONLY");
+  mlp->opt_dbg_feasibility_only = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DBG_FEASIBILITY_ONLY");
   if (GNUNET_SYSERR == mlp->opt_dbg_feasibility_only)
     mlp->opt_dbg_feasibility_only = GNUNET_NO;
   if (GNUNET_YES == mlp->opt_dbg_feasibility_only)
-    LOG(GNUNET_ERROR_TYPE_WARNING,
-        "MLP solver is configured to check feasibility only!\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "MLP solver is configured to check feasibility only!\n");
 
-  mlp->opt_dbg_autoscale_problem = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                        "ats", "MLP_DBG_AUTOSCALE_PROBLEM");
+  mlp->opt_dbg_autoscale_problem = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DBG_AUTOSCALE_PROBLEM");
   if (GNUNET_SYSERR == mlp->opt_dbg_autoscale_problem)
     mlp->opt_dbg_autoscale_problem = GNUNET_NO;
   if (GNUNET_YES == mlp->opt_dbg_autoscale_problem)
-    LOG(GNUNET_ERROR_TYPE_WARNING,
-        "MLP solver is configured automatically scale the problem!\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "MLP solver is configured automatically scale the problem!\n");
 
-  mlp->opt_dbg_intopt_presolver = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                       "ats", "MLP_DBG_INTOPT_PRESOLVE");
+  mlp->opt_dbg_intopt_presolver = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DBG_INTOPT_PRESOLVE");
   if (GNUNET_SYSERR == mlp->opt_dbg_intopt_presolver)
     mlp->opt_dbg_intopt_presolver = GNUNET_NO;
   if (GNUNET_YES == mlp->opt_dbg_intopt_presolver)
-    LOG(GNUNET_ERROR_TYPE_WARNING,
-        "MLP solver is configured use the mlp presolver\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "MLP solver is configured use the mlp presolver\n");
 
-  mlp->opt_dbg_optimize_diversity = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                         "ats", "MLP_DBG_OPTIMIZE_DIVERSITY");
+  mlp->opt_dbg_optimize_diversity = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DBG_OPTIMIZE_DIVERSITY");
   if (GNUNET_SYSERR == mlp->opt_dbg_optimize_diversity)
     mlp->opt_dbg_optimize_diversity = GNUNET_YES;
   if (GNUNET_NO == mlp->opt_dbg_optimize_diversity)
-    LOG(GNUNET_ERROR_TYPE_WARNING,
-        "MLP solver is not optimizing for diversity\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "MLP solver is not optimizing for diversity\n");
 
-  mlp->opt_dbg_optimize_relativity = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                          "ats", "MLP_DBG_OPTIMIZE_RELATIVITY");
+  mlp->opt_dbg_optimize_relativity = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DBG_OPTIMIZE_RELATIVITY");
   if (GNUNET_SYSERR == mlp->opt_dbg_optimize_relativity)
     mlp->opt_dbg_optimize_relativity = GNUNET_YES;
   if (GNUNET_NO == mlp->opt_dbg_optimize_relativity)
-    LOG(GNUNET_ERROR_TYPE_WARNING,
-        "MLP solver is not optimizing for relativity\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "MLP solver is not optimizing for relativity\n");
 
-  mlp->opt_dbg_optimize_quality = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                       "ats", "MLP_DBG_OPTIMIZE_QUALITY");
+  mlp->opt_dbg_optimize_quality = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DBG_OPTIMIZE_QUALITY");
   if (GNUNET_SYSERR == mlp->opt_dbg_optimize_quality)
     mlp->opt_dbg_optimize_quality = GNUNET_YES;
   if (GNUNET_NO == mlp->opt_dbg_optimize_quality)
-    LOG(GNUNET_ERROR_TYPE_WARNING,
-        "MLP solver is not optimizing for quality\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "MLP solver is not optimizing for quality\n");
 
-  mlp->opt_dbg_optimize_utility = GNUNET_CONFIGURATION_get_value_yesno(env->cfg,
-                                                                       "ats", "MLP_DBG_OPTIMIZE_UTILITY");
+  mlp->opt_dbg_optimize_utility = GNUNET_CONFIGURATION_get_value_yesno (
+    env->cfg,
+    "ats",
+    "MLP_DBG_OPTIMIZE_UTILITY");
   if (GNUNET_SYSERR == mlp->opt_dbg_optimize_utility)
     mlp->opt_dbg_optimize_utility = GNUNET_YES;
   if (GNUNET_NO == mlp->opt_dbg_optimize_utility)
-    LOG(GNUNET_ERROR_TYPE_WARNING,
-        "MLP solver is not optimizing for utility\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "MLP solver is not optimizing for utility\n");
 
   if ((GNUNET_NO == mlp->opt_dbg_optimize_utility) &&
       (GNUNET_NO == mlp->opt_dbg_optimize_quality) &&
       (GNUNET_NO == mlp->opt_dbg_optimize_relativity) &&
       (GNUNET_NO == mlp->opt_dbg_optimize_utility) &&
       (GNUNET_NO == mlp->opt_dbg_feasibility_only))
-    {
-      LOG(GNUNET_ERROR_TYPE_ERROR,
-          _("MLP solver is not optimizing for anything, changing to feasibility check\n"));
-      mlp->opt_dbg_feasibility_only = GNUNET_YES;
-    }
-
-  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(env->cfg,
-                                                             "ats", "MLP_LOG_FORMAT", &outputformat))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ (
+           "MLP solver is not optimizing for anything, changing to feasibility check\n"));
+    mlp->opt_dbg_feasibility_only = GNUNET_YES;
+  }
+
+  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                                              "ats",
+                                                              "MLP_LOG_FORMAT",
+                                                              &outputformat))
     mlp->opt_log_format = MLP_CPLEX;
   else
+  {
+    GNUNET_STRINGS_utf8_toupper (outputformat, outputformat);
+    if (0 == strcmp (outputformat, "MPS"))
     {
-      GNUNET_STRINGS_utf8_toupper(outputformat, outputformat);
-      if (0 == strcmp(outputformat, "MPS"))
-        {
-          mlp->opt_log_format = MLP_MPS;
-        }
-      else if (0 == strcmp(outputformat, "CPLEX"))
-        {
-          mlp->opt_log_format = MLP_CPLEX;
-        }
-      else if (0 == strcmp(outputformat, "GLPK"))
-        {
-          mlp->opt_log_format = MLP_GLPK;
-        }
-      else
-        {
-          LOG(GNUNET_ERROR_TYPE_WARNING,
-              "Invalid log format `%s' in configuration, using CPLEX!\n",
-              outputformat);
-          mlp->opt_log_format = MLP_CPLEX;
-        }
-      GNUNET_free(outputformat);
+      mlp->opt_log_format = MLP_MPS;
+    }
+    else if (0 == strcmp (outputformat, "CPLEX"))
+    {
+      mlp->opt_log_format = MLP_CPLEX;
+    }
+    else if (0 == strcmp (outputformat, "GLPK"))
+    {
+      mlp->opt_log_format = MLP_GLPK;
+    }
+    else
+    {
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Invalid log format `%s' in configuration, using CPLEX!\n",
+           outputformat);
+      mlp->opt_log_format = MLP_CPLEX;
     }
+    GNUNET_free (outputformat);
+  }
 
-  mlp->pv.BIG_M = (double)BIG_M_VALUE;
+  mlp->pv.BIG_M = (double) BIG_M_VALUE;
 
-  mlp->pv.mip_gap = (double)0.0;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "MLP_MAX_MIP_GAP", &f_tmp))
+  mlp->pv.mip_gap = (double) 0.0;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "MLP_MAX_MIP_GAP",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0) || (f_tmp > 1.0))
     {
-      if ((f_tmp < 0.0) || (f_tmp > 1.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "MIP gap", f_tmp);
-        }
-      else
-        {
-          mlp->pv.mip_gap = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "MIP gap", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "MIP gap", f_tmp);
     }
-
-  mlp->pv.lp_mip_gap = (double)0.0;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "MLP_MAX_LP_MIP_GAP", &f_tmp))
+    else
     {
-      if ((f_tmp < 0.0) || (f_tmp > 1.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "LP/MIP", f_tmp);
-        }
-      else
-        {
-          mlp->pv.lp_mip_gap = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
-              "LP/MIP", f_tmp);
-        }
+      mlp->pv.mip_gap = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "MIP gap", f_tmp);
     }
+  }
 
-  /* Get timeout for iterations */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(env->cfg, "ats",
-                                                       "MLP_MAX_DURATION", &max_duration))
+  mlp->pv.lp_mip_gap = (double) 0.0;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "MLP_MAX_LP_MIP_GAP",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0) || (f_tmp > 1.0))
     {
-      max_duration = MLP_MAX_EXEC_DURATION;
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "LP/MIP", f_tmp);
     }
-
-  /* Get maximum number of iterations */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_size(env->cfg, "ats",
-                                                       "MLP_MAX_ITERATIONS", &max_iterations))
+    else
     {
-      max_iterations = MLP_MAX_ITERATIONS;
+      mlp->pv.lp_mip_gap = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
+           "LP/MIP", f_tmp);
     }
+  }
+
+  /* Get timeout for iterations */
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (env->cfg, "ats",
+                                                        "MLP_MAX_DURATION",
+                                                        &max_duration))
+  {
+    max_duration = MLP_MAX_EXEC_DURATION;
+  }
+
+  /* Get maximum number of iterations */
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
+                                                        "MLP_MAX_ITERATIONS",
+                                                        &max_iterations))
+  {
+    max_iterations = MLP_MAX_ITERATIONS;
+  }
 
   /* Get diversity coefficient from configuration */
   mlp->pv.co_D = MLP_DEFAULT_D;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "MLP_COEFFICIENT_D", &f_tmp))
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "MLP_COEFFICIENT_D",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0))
     {
-      if ((f_tmp < 0.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "MLP_COEFFICIENT_D", f_tmp);
-        }
-      else
-        {
-          mlp->pv.co_D = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
-              "MLP_COEFFICIENT_D", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "MLP_COEFFICIENT_D", f_tmp);
+    }
+    else
+    {
+      mlp->pv.co_D = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
+           "MLP_COEFFICIENT_D", f_tmp);
     }
+  }
 
   /* Get relativity coefficient from configuration */
   mlp->pv.co_R = MLP_DEFAULT_R;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "MLP_COEFFICIENT_R", &f_tmp))
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "MLP_COEFFICIENT_R",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0))
     {
-      if ((f_tmp < 0.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "MLP_COEFFICIENT_R", f_tmp);
-        }
-      else
-        {
-          mlp->pv.co_R = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
-              "MLP_COEFFICIENT_R", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "MLP_COEFFICIENT_R", f_tmp);
+    }
+    else
+    {
+      mlp->pv.co_R = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
+           "MLP_COEFFICIENT_R", f_tmp);
     }
+  }
 
 
   /* Get utilization coefficient from configuration */
   mlp->pv.co_U = MLP_DEFAULT_U;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "MLP_COEFFICIENT_U", &f_tmp))
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "MLP_COEFFICIENT_U",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0))
     {
-      if ((f_tmp < 0.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "MLP_COEFFICIENT_U", f_tmp);
-        }
-      else
-        {
-          mlp->pv.co_U = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
-              "MLP_COEFFICIENT_U", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "MLP_COEFFICIENT_U", f_tmp);
     }
+    else
+    {
+      mlp->pv.co_U = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s gap of %.3f\n",
+           "MLP_COEFFICIENT_U", f_tmp);
+    }
+  }
 
   /* Get quality metric coefficients from configuration */
   for (c = 0; c < RQ_QUALITY_METRIC_COUNT; c++)
-    {
-      /* initialize quality coefficients with default value 1.0 */
-      mlp->pv.co_Q[c] = MLP_DEFAULT_QUALITY;
-    }
+  {
+    /* initialize quality coefficients with default value 1.0 */
+    mlp->pv.co_Q[c] = MLP_DEFAULT_QUALITY;
+  }
 
 
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_size(env->cfg, "ats",
-                                          "MLP_COEFFICIENT_QUALITY_DELAY",
-                                          &tmp))
-    mlp->pv.co_Q[RQ_QUALITY_METRIC_DELAY] = (double)tmp / 100;
+      GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
+                                           "MLP_COEFFICIENT_QUALITY_DELAY",
+                                           &tmp))
+    mlp->pv.co_Q[RQ_QUALITY_METRIC_DELAY] = (double) tmp / 100;
   else
     mlp->pv.co_Q[RQ_QUALITY_METRIC_DELAY] = MLP_DEFAULT_QUALITY;
 
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_size(env->cfg, "ats",
-                                          "MLP_COEFFICIENT_QUALITY_DISTANCE",
-                                          &tmp))
-    mlp->pv.co_Q[RQ_QUALITY_METRIC_DISTANCE] = (double)tmp / 100;
+      GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
+                                           "MLP_COEFFICIENT_QUALITY_DISTANCE",
+                                           &tmp))
+    mlp->pv.co_Q[RQ_QUALITY_METRIC_DISTANCE] = (double) tmp / 100;
   else
     mlp->pv.co_Q[RQ_QUALITY_METRIC_DISTANCE] = MLP_DEFAULT_QUALITY;
 
   /* Get minimum bandwidth per used address from configuration */
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size(env->cfg, "ats",
-                                                       "MLP_MIN_BANDWIDTH",
-                                                       &tmp))
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
+                                                        "MLP_MIN_BANDWIDTH",
+                                                        &tmp))
     b_min = tmp;
   else
-    {
-      b_min = ntohl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
-    }
+  {
+    b_min = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
+  }
 
   /* Get minimum number of connections from configuration */
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size(env->cfg, "ats",
-                                                       "MLP_MIN_CONNECTIONS",
-                                                       &tmp))
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
+                                                        "MLP_MIN_CONNECTIONS",
+                                                        &tmp))
     n_min = tmp;
   else
     n_min = MLP_DEFAULT_MIN_CONNECTIONS;
 
   /* Init network quotas */
   for (c = 0; c < GNUNET_NT_COUNT; c++)
-    {
-      mlp->pv.quota_index[c] = c;
-      mlp->pv.quota_out[c] = env->out_quota[c];
-      mlp->pv.quota_in[c] = env->in_quota[c];
-
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Quota for network `%s' (in/out) %llu/%llu\n",
-          GNUNET_NT_to_string(c),
-          mlp->pv.quota_out[c],
-          mlp->pv.quota_in[c]);
-      /* Check if defined quota could make problem unsolvable */
-      if ((n_min * b_min) > mlp->pv.quota_out[c])
-        {
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              _("Adjusting inconsistent outbound quota configuration for network `%s', is %llu must be at least %llu\n"),
-              GNUNET_NT_to_string(mlp->pv.quota_index[c]),
-              mlp->pv.quota_out[c],
-              (n_min * b_min));
-          mlp->pv.quota_out[c] = (n_min * b_min);
-        }
-      if ((n_min * b_min) > mlp->pv.quota_in[c])
-        {
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              _("Adjusting inconsistent inbound quota configuration for network `%s', is %llu must be at least %llu\n"),
-              GNUNET_NT_to_string(mlp->pv.quota_index[c]),
-              mlp->pv.quota_in[c],
-              (n_min * b_min));
-          mlp->pv.quota_in[c] = (n_min * b_min);
-        }
-      /* Check if bandwidth is too big to make problem solvable */
-      if (mlp->pv.BIG_M < mlp->pv.quota_out[c])
-        {
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              _("Adjusting outbound quota configuration for network `%s'from %llu to %.0f\n"),
-              GNUNET_NT_to_string(mlp->pv.quota_index[c]),
-              mlp->pv.quota_out[c],
-              mlp->pv.BIG_M);
-          mlp->pv.quota_out[c] = mlp->pv.BIG_M;
-        }
-      if (mlp->pv.BIG_M < mlp->pv.quota_in[c])
-        {
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              _("Adjusting inbound quota configuration for network `%s' from %llu to %.0f\n"),
-              GNUNET_NT_to_string(mlp->pv.quota_index[c]),
-              mlp->pv.quota_in[c],
-              mlp->pv.BIG_M);
-          mlp->pv.quota_in[c] = mlp->pv.BIG_M;
-        }
-    }
+  {
+    mlp->pv.quota_index[c] = c;
+    mlp->pv.quota_out[c] = env->out_quota[c];
+    mlp->pv.quota_in[c] = env->in_quota[c];
+
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Quota for network `%s' (in/out) %llu/%llu\n",
+         GNUNET_NT_to_string (c),
+         mlp->pv.quota_out[c],
+         mlp->pv.quota_in[c]);
+    /* Check if defined quota could make problem unsolvable */
+    if ((n_min * b_min) > mlp->pv.quota_out[c])
+    {
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _ (
+             "Adjusting inconsistent outbound quota configuration for network `%s', is %llu must be at least %llu\n"),
+           GNUNET_NT_to_string (mlp->pv.quota_index[c]),
+           mlp->pv.quota_out[c],
+           (n_min * b_min));
+      mlp->pv.quota_out[c] = (n_min * b_min);
+    }
+    if ((n_min * b_min) > mlp->pv.quota_in[c])
+    {
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _ (
+             "Adjusting inconsistent inbound quota configuration for network `%s', is %llu must be at least %llu\n"),
+           GNUNET_NT_to_string (mlp->pv.quota_index[c]),
+           mlp->pv.quota_in[c],
+           (n_min * b_min));
+      mlp->pv.quota_in[c] = (n_min * b_min);
+    }
+    /* Check if bandwidth is too big to make problem solvable */
+    if (mlp->pv.BIG_M < mlp->pv.quota_out[c])
+    {
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _ (
+             "Adjusting outbound quota configuration for network `%s'from %llu to %.0f\n"),
+           GNUNET_NT_to_string (mlp->pv.quota_index[c]),
+           mlp->pv.quota_out[c],
+           mlp->pv.BIG_M);
+      mlp->pv.quota_out[c] = mlp->pv.BIG_M;
+    }
+    if (mlp->pv.BIG_M < mlp->pv.quota_in[c])
+    {
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _ (
+             "Adjusting inbound quota configuration for network `%s' from %llu to %.0f\n"),
+           GNUNET_NT_to_string (mlp->pv.quota_index[c]),
+           mlp->pv.quota_in[c],
+           mlp->pv.BIG_M);
+      mlp->pv.quota_in[c] = mlp->pv.BIG_M;
+    }
+  }
   mlp->env = env;
   sf.cls = mlp;
   sf.s_add = &GAS_mlp_address_add;
@@ -2770,16 +2888,16 @@ libgnunet_plugin_ats_mlp_init(void *cls)
   mlp->stat_mlp_prob_changed = GNUNET_NO;
   mlp->stat_mlp_prob_updated = GNUNET_NO;
   mlp->opt_mlp_auto_solve = GNUNET_YES;
-  mlp->requested_peers = GNUNET_CONTAINER_multipeermap_create(10, GNUNET_NO);
+  mlp->requested_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
   mlp->stat_bulk_requests = 0;
   mlp->stat_bulk_lock = 0;
 
   /* Setup GLPK */
   /* Redirect GLPK output to GNUnet logging */
-  glp_term_hook(&mlp_term_hook, (void *)mlp);
+  glp_term_hook (&mlp_term_hook, (void *) mlp);
 
   /* Init LP solving parameters */
-  glp_init_smcp(&mlp->control_param_lp);
+  glp_init_smcp (&mlp->control_param_lp);
   mlp->control_param_lp.msg_lev = GLP_MSG_OFF;
   if (GNUNET_YES == mlp->opt_dbg_glpk_verbose)
     mlp->control_param_lp.msg_lev = GLP_MSG_ALL;
@@ -2788,7 +2906,7 @@ libgnunet_plugin_ats_mlp_init(void *cls)
   mlp->control_param_lp.tm_lim = max_duration.rel_value_us / 1000LL;
 
   /* Init MLP solving parameters */
-  glp_init_iocp(&mlp->control_param_mlp);
+  glp_init_iocp (&mlp->control_param_mlp);
   /* Setting callback function */
   mlp->control_param_mlp.cb_func = &mlp_branch_and_cut_cb;
   mlp->control_param_mlp.cb_info = mlp;
@@ -2798,7 +2916,7 @@ libgnunet_plugin_ats_mlp_init(void *cls)
     mlp->control_param_mlp.msg_lev = GLP_MSG_ALL;
   mlp->control_param_mlp.tm_lim = max_duration.rel_value_us / 1000LL;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "solver ready\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "solver ready\n");
 
   return &sf;
 }
diff --git a/src/ats/plugin_ats_proportional.c b/src/ats/plugin_ats_proportional.c
index bdb5d6cf0..a1e995013 100644
--- a/src/ats/plugin_ats_proportional.c
+++ b/src/ats/plugin_ats_proportional.c
@@ -29,7 +29,7 @@
 #include "gnunet_ats_plugin.h"
 #include "gnunet-service-ats_addresses.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-proportional", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-proportional", __VA_ARGS__)
 
 /**
  * How much do we value stability over adaptation by default.  A low
@@ -58,7 +58,8 @@
  * They are also stored in the respective `struct Network`'s linked
  * list.
  */
-struct AddressWrapper {
+struct AddressWrapper
+{
   /**
    * Next in DLL
    */
@@ -99,7 +100,8 @@ struct AddressWrapper {
 /**
  * Representation of a network
  */
-struct Network {
+struct Network
+{
   /**
    * Network description
    */
@@ -155,7 +157,8 @@ struct Network {
 /**
  * A handle for the proportional solver
  */
-struct GAS_PROPORTIONAL_Handle {
+struct GAS_PROPORTIONAL_Handle
+{
   /**
    * Our execution environment.
    */
@@ -202,13 +205,13 @@ struct GAS_PROPORTIONAL_Handle {
  * @return #GNUNET_YES or #GNUNET_NO
  */
 static int
-is_bandwidth_available_in_network(struct Network *net,
-                                  int extra)
+is_bandwidth_available_in_network (struct Network *net,
+                                   int extra)
 {
   unsigned int na;
-  uint32_t min_bw = ntohl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
+  uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
 
-  GNUNET_assert(((int)net->active_addresses) + extra >= 0);
+  GNUNET_assert (((int) net->active_addresses) + extra >= 0);
   na = net->active_addresses + extra;
   if (0 == na)
     return GNUNET_YES;
@@ -229,16 +232,16 @@ is_bandwidth_available_in_network(struct Network *net,
  * @return #GNUNET_YES or #GNUNET_NO
  */
 static int
-all_require_connectivity(struct GAS_PROPORTIONAL_Handle *s,
-                         struct Network *net,
-                         unsigned int con)
+all_require_connectivity (struct GAS_PROPORTIONAL_Handle *s,
+                          struct Network *net,
+                          unsigned int con)
 {
   struct AddressWrapper *aw;
 
   for (aw = net->head; NULL != aw; aw = aw->next)
     if (con >
-        s->env->get_connectivity(s->env->cls,
-                                 &aw->addr->peer))
+        s->env->get_connectivity (s->env->cls,
+                                  &aw->addr->peer))
       return GNUNET_NO;
   return GNUNET_YES;
 }
@@ -254,10 +257,10 @@ all_require_connectivity(struct GAS_PROPORTIONAL_Handle *s,
  * @param net the network type to update
  */
 static void
-distribute_bandwidth(struct GAS_PROPORTIONAL_Handle *s,
-                     struct Network *net)
+distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s,
+                      struct Network *net)
 {
-  const uint32_t min_bw = ntohl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
+  const uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
   struct AddressWrapper *aw;
   unsigned long long remaining_quota_in;
   unsigned long long quota_out_used;
@@ -269,110 +272,113 @@ distribute_bandwidth(struct GAS_PROPORTIONAL_Handle *s,
   double total_weight;
   const double *peer_relative_prefs;
 
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "Recalculate quota for network type `%s' for %u addresses (in/out): %llu/%llu \n",
-      net->desc,
-      net->active_addresses,
-      net->total_quota_in,
-      net->total_quota_in);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Recalculate quota for network type `%s' for %u addresses (in/out): %llu/%llu \n",
+       net->desc,
+       net->active_addresses,
+       net->total_quota_in,
+       net->total_quota_in);
 
   if (0 == net->active_addresses)
     return; /* no addresses to update */
 
   /* sanity checks */
   if ((net->active_addresses * min_bw) > net->total_quota_in)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   if ((net->active_addresses * min_bw) > net->total_quota_out)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
 
   /* Calculate sum of relative preference for active addresses in this
      network */
   sum_relative_peer_prefences = 0.0;
   count_addresses = 0;
   for (aw = net->head; NULL != aw; aw = aw->next)
-    {
-      if (GNUNET_YES != aw->addr->active)
-        continue;
-      peer_relative_prefs = s->env->get_preferences(s->env->cls,
-                                                    &aw->addr->peer);
-      sum_relative_peer_prefences
-        += peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
-      count_addresses++;
-    }
+  {
+    if (GNUNET_YES != aw->addr->active)
+      continue;
+    peer_relative_prefs = s->env->get_preferences (s->env->cls,
+                                                   &aw->addr->peer);
+    sum_relative_peer_prefences
+      += peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
+    count_addresses++;
+  }
   if (count_addresses != net->active_addresses)
-    {
-      GNUNET_break(0);
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "%s: Counted %u active addresses, expected %u active addresses\n",
-          net->desc,
-          count_addresses,
-          net->active_addresses);
-      /* try to fix... */
-      net->active_addresses = count_addresses;
-    }
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "Total relative preference %.3f for %u addresses in network %s\n",
-      sum_relative_peer_prefences,
-      net->active_addresses,
-      net->desc);
+  {
+    GNUNET_break (0);
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "%s: Counted %u active addresses, expected %u active addresses\n",
+         net->desc,
+         count_addresses,
+         net->active_addresses);
+    /* try to fix... */
+    net->active_addresses = count_addresses;
+  }
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Total relative preference %.3f for %u addresses in network %s\n",
+       sum_relative_peer_prefences,
+       net->active_addresses,
+       net->desc);
 
   /* check how much we have to distribute */
   remaining_quota_in = net->total_quota_in - (net->active_addresses * min_bw);
   remaining_quota_out = net->total_quota_out - (net->active_addresses * min_bw);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Proportionally distributable bandwidth (in/out): %llu/%llu\n",
-      remaining_quota_in,
-      remaining_quota_out);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Proportionally distributable bandwidth (in/out): %llu/%llu\n",
+       remaining_quota_in,
+       remaining_quota_out);
 
   /* distribute remaining quota; we do not do it exactly proportional,
      but balance "even" distribution ("net->active_addresses") with
      the preference sum using the "prop_factor". */
-  total_weight = net->active_addresses +
-                 s->prop_factor * sum_relative_peer_prefences;
+  total_weight = net->active_addresses
+                 + s->prop_factor * sum_relative_peer_prefences;
   quota_out_used = 0;
   quota_in_used = 0;
   for (aw = net->head; NULL != aw; aw = aw->next)
+  {
+    if (GNUNET_YES != aw->addr->active)
     {
-      if (GNUNET_YES != aw->addr->active)
-        {
-          /* set to 0, just to be sure */
-          aw->calculated_quota_in = 0;
-          aw->calculated_quota_out = 0;
-          continue;
-        }
-      peer_relative_prefs = s->env->get_preferences(s->env->cls,
-                                                    &aw->addr->peer);
-      peer_weight = 1.0
-                    + s->prop_factor * peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
-
-      aw->calculated_quota_in = min_bw
-                                + (peer_weight / total_weight) * remaining_quota_in;
-      aw->calculated_quota_out = min_bw
-                                 + (peer_weight / total_weight) * remaining_quota_out;
-
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "New quotas for peer `%s' with weight (cur/total) %.3f/%.3f (in/out) are: %u/%u\n",
-          GNUNET_i2s(&aw->addr->peer),
-          peer_weight,
-          total_weight,
-          (unsigned int)aw->calculated_quota_in,
-          (unsigned int)aw->calculated_quota_out);
-      quota_in_used += aw->calculated_quota_in;
-      quota_out_used += aw->calculated_quota_out;
+      /* set to 0, just to be sure */
+      aw->calculated_quota_in = 0;
+      aw->calculated_quota_out = 0;
+      continue;
     }
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Total bandwidth assigned is (in/out): %llu /%llu\n",
-      quota_in_used,
-      quota_out_used);
+    peer_relative_prefs = s->env->get_preferences (s->env->cls,
+                                                   &aw->addr->peer);
+    peer_weight = 1.0
+                  + s->prop_factor
+                  * peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
+
+    aw->calculated_quota_in = min_bw
+                              + (peer_weight / total_weight)
+                              * remaining_quota_in;
+    aw->calculated_quota_out = min_bw
+                               + (peer_weight / total_weight)
+                               * remaining_quota_out;
+
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "New quotas for peer `%s' with weight (cur/total) %.3f/%.3f (in/out) are: %u/%u\n",
+         GNUNET_i2s (&aw->addr->peer),
+         peer_weight,
+         total_weight,
+         (unsigned int) aw->calculated_quota_in,
+         (unsigned int) aw->calculated_quota_out);
+    quota_in_used += aw->calculated_quota_in;
+    quota_out_used += aw->calculated_quota_out;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Total bandwidth assigned is (in/out): %llu /%llu\n",
+       quota_in_used,
+       quota_out_used);
   /* +1 due to possible rounding errors */
-  GNUNET_break(quota_out_used <= net->total_quota_out + 1);
-  GNUNET_break(quota_in_used <= net->total_quota_in + 1);
+  GNUNET_break (quota_out_used <= net->total_quota_out + 1);
+  GNUNET_break (quota_in_used <= net->total_quota_in + 1);
 }
 
 
@@ -383,22 +389,22 @@ distribute_bandwidth(struct GAS_PROPORTIONAL_Handle *s,
  * @param net the network to propagate changes in
  */
 static void
-propagate_bandwidth(struct GAS_PROPORTIONAL_Handle *s,
-                    struct Network *net)
+propagate_bandwidth (struct GAS_PROPORTIONAL_Handle *s,
+                     struct Network *net)
 {
   struct AddressWrapper *cur;
 
   for (cur = net->head; NULL != cur; cur = cur->next)
-    {
-      if ((cur->addr->assigned_bw_in == cur->calculated_quota_in) &&
-          (cur->addr->assigned_bw_out == cur->calculated_quota_out))
-        continue;
-      cur->addr->assigned_bw_in = cur->calculated_quota_in;
-      cur->addr->assigned_bw_out = cur->calculated_quota_out;
-      if (GNUNET_YES == cur->addr->active)
-        s->env->bandwidth_changed_cb(s->env->cls,
-                                     cur->addr);
-    }
+  {
+    if ((cur->addr->assigned_bw_in == cur->calculated_quota_in) &&
+        (cur->addr->assigned_bw_out == cur->calculated_quota_out))
+      continue;
+    cur->addr->assigned_bw_in = cur->calculated_quota_in;
+    cur->addr->assigned_bw_out = cur->calculated_quota_out;
+    if (GNUNET_YES == cur->addr->active)
+      s->env->bandwidth_changed_cb (s->env->cls,
+                                    cur->addr);
+  }
 }
 
 
@@ -410,80 +416,81 @@ propagate_bandwidth(struct GAS_PROPORTIONAL_Handle *s,
  * @param n the network, can be NULL for all networks
  */
 static void
-distribute_bandwidth_in_network(struct GAS_PROPORTIONAL_Handle *s,
-                                struct Network *n)
+distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s,
+                                 struct Network *n)
 {
   unsigned int i;
 
   if (0 != s->bulk_lock)
-    {
-      s->bulk_requests++;
-      return;
-    }
+  {
+    s->bulk_requests++;
+    return;
+  }
   if (NULL != n)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Redistributing bandwidth in network %s with %u active and %u total addresses\n",
-          GNUNET_NT_to_string(n->type),
-          n->active_addresses,
-          n->total_addresses);
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_START,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_SINGLE);
-      distribute_bandwidth(s,
-                           n);
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_STOP,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_SINGLE);
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_SINGLE);
-      propagate_bandwidth(s,
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Redistributing bandwidth in network %s with %u active and %u total addresses\n",
+         GNUNET_NT_to_string (n->type),
+         n->active_addresses,
+         n->total_addresses);
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_START,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_SINGLE);
+    distribute_bandwidth (s,
                           n);
-
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_SINGLE);
-    }
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_STOP,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_SINGLE);
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_SINGLE);
+    propagate_bandwidth (s,
+                         n);
+
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_SINGLE);
+  }
   else
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Redistributing bandwidth in all %u networks\n",
-          s->env->network_count);
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_START,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_ALL);
-      for (i = 0; i < s->env->network_count; i++)
-        distribute_bandwidth(s,
-                             &s->network_entries[i]);
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_STOP,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_ALL);
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_ALL);
-      for (i = 0; i < s->env->network_count; i++)
-        propagate_bandwidth(s,
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Redistributing bandwidth in all %u networks\n",
+         s->env->network_count);
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_START,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_ALL);
+    for (i = 0; i < s->env->network_count; i++)
+      distribute_bandwidth (s,
                             &s->network_entries[i]);
-      s->env->info_cb(s->env->cls,
-                      GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
-                      GAS_STAT_SUCCESS,
-                      GAS_INFO_PROP_ALL);
-    }
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_STOP,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_ALL);
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_ALL);
+    for (i = 0; i < s->env->network_count; i++)
+      propagate_bandwidth (s,
+                           &s->network_entries[i]);
+    s->env->info_cb (s->env->cls,
+                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
+                     GAS_STAT_SUCCESS,
+                     GAS_INFO_PROP_ALL);
+  }
 }
 
 
 /**
  * Context for finding the best address* Linked list of addresses in this network: head
  */
-struct FindBestAddressCtx {
+struct FindBestAddressCtx
+{
   /**
    * The solver handle
    */
@@ -508,9 +515,9 @@ struct FindBestAddressCtx {
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-find_best_address_it(void *cls,
-                     const struct GNUNET_PeerIdentity *key,
-                     void *value)
+find_best_address_it (void *cls,
+                      const struct GNUNET_PeerIdentity *key,
+                      void *value)
 {
   struct FindBestAddressCtx *ctx = cls;
   struct ATS_Address *current = value;
@@ -530,46 +537,47 @@ find_best_address_it(void *cls,
      to the same network (as we would replace it) */
   if ((NULL != ctx->best) &&
       (GNUNET_YES == ctx->best->active) &&
-      (((struct AddressWrapper *)ctx->best->solver_information)->network ==
+      (((struct AddressWrapper *) ctx->best->solver_information)->network ==
        asi->network))
     need--;
   /* we can gain -1 slot if this peers connectivity
      requirement is higher than that of another peer
      in that network scope */
-  con = ctx->s->env->get_connectivity(ctx->s->env->cls,
-                                      key);
+  con = ctx->s->env->get_connectivity (ctx->s->env->cls,
+                                       key);
   if (GNUNET_YES !=
-      all_require_connectivity(ctx->s,
-                               asi->network,
-                               con))
+      all_require_connectivity (ctx->s,
+                                asi->network,
+                                con))
     need--;
   /* test if minimum bandwidth for 'current' would be available */
   bw_available
-    = is_bandwidth_available_in_network(asi->network,
-                                        need);
-  if (!bw_available)
-    {
-      /* Bandwidth for this address is unavailable, so we cannot use
-         it. */
-      return GNUNET_OK;
-    }
+    = is_bandwidth_available_in_network (asi->network,
+                                         need);
+  if (! bw_available)
+  {
+    /* Bandwidth for this address is unavailable, so we cannot use
+       it. */
+    return GNUNET_OK;
+  }
   if (GNUNET_YES == current->active)
+  {
+    active_time = GNUNET_TIME_absolute_get_duration (asi->activated);
+    if (active_time.rel_value_us <=
+        ((double) GNUNET_TIME_UNIT_SECONDS.rel_value_us)
+        * ctx->s->stability_factor)
     {
-      active_time = GNUNET_TIME_absolute_get_duration(asi->activated);
-      if (active_time.rel_value_us <=
-          ((double)GNUNET_TIME_UNIT_SECONDS.rel_value_us) * ctx->s->stability_factor)
-        {
-          /* Keep active address for stability reasons */
-          ctx->best = current;
-          return GNUNET_NO;
-        }
-    }
-  if (NULL == ctx->best)
-    {
-      /* We so far have nothing else, so go with it! */
+      /* Keep active address for stability reasons */
       ctx->best = current;
-      return GNUNET_OK;
+      return GNUNET_NO;
     }
+  }
+  if (NULL == ctx->best)
+  {
+    /* We so far have nothing else, so go with it! */
+    ctx->best = current;
+    return GNUNET_OK;
+  }
 
   /* Now compare ATS information */
   cur_distance = current->norm_distance.norm;
@@ -579,33 +587,33 @@ find_best_address_it(void *cls,
 
   /* user shorter distance */
   if (cur_distance < best_distance)
+  {
+    if (GNUNET_NO == ctx->best->active)
     {
-      if (GNUNET_NO == ctx->best->active)
-        {
-          /* Activity doesn't influence the equation, use current */
-          ctx->best = current;
-        }
-      else if ((best_distance / cur_distance) > ctx->s->stability_factor)
-        {
-          /* Distance change is significant, switch active address! */
-          ctx->best = current;
-        }
+      /* Activity doesn't influence the equation, use current */
+      ctx->best = current;
     }
+    else if ((best_distance / cur_distance) > ctx->s->stability_factor)
+    {
+      /* Distance change is significant, switch active address! */
+      ctx->best = current;
+    }
+  }
 
   /* User connection with less delay */
   if (cur_delay < best_delay)
+  {
+    if (GNUNET_NO == ctx->best->active)
+    {
+      /* Activity doesn't influence the equation, use current */
+      ctx->best = current;
+    }
+    else if ((best_delay / cur_delay) > ctx->s->stability_factor)
     {
-      if (GNUNET_NO == ctx->best->active)
-        {
-          /* Activity doesn't influence the equation, use current */
-          ctx->best = current;
-        }
-      else if ((best_delay / cur_delay) > ctx->s->stability_factor)
-        {
-          /* Latency change is significant, switch active address! */
-          ctx->best = current;
-        }
+      /* Latency change is significant, switch active address! */
+      ctx->best = current;
     }
+  }
   return GNUNET_OK;
 }
 
@@ -620,18 +628,18 @@ find_best_address_it(void *cls,
  * @return the address or NULL
  */
 struct ATS_Address *
-get_best_address(struct GAS_PROPORTIONAL_Handle *s,
-                 struct GNUNET_CONTAINER_MultiPeerMap *addresses,
-                 const struct GNUNET_PeerIdentity *id)
+get_best_address (struct GAS_PROPORTIONAL_Handle *s,
+                  struct GNUNET_CONTAINER_MultiPeerMap *addresses,
+                  const struct GNUNET_PeerIdentity *id)
 {
   struct FindBestAddressCtx fba_ctx;
 
   fba_ctx.best = NULL;
   fba_ctx.s = s;
-  GNUNET_CONTAINER_multipeermap_get_multiple(addresses,
-                                             id,
-                                             &find_best_address_it,
-                                             &fba_ctx);
+  GNUNET_CONTAINER_multipeermap_get_multiple (addresses,
+                                              id,
+                                              &find_best_address_it,
+                                              &fba_ctx);
   return fba_ctx.best;
 }
 
@@ -643,21 +651,21 @@ get_best_address(struct GAS_PROPORTIONAL_Handle *s,
  * @param net the network type
  */
 static void
-address_decrement_active(struct GAS_PROPORTIONAL_Handle *s,
-                         struct Network *net)
+address_decrement_active (struct GAS_PROPORTIONAL_Handle *s,
+                          struct Network *net)
 {
-  GNUNET_assert(net->active_addresses > 0);
+  GNUNET_assert (net->active_addresses > 0);
   net->active_addresses--;
-  GNUNET_STATISTICS_update(s->env->stats,
-                           net->stat_active,
-                           -1,
-                           GNUNET_NO);
-  GNUNET_assert(s->active_addresses > 0);
+  GNUNET_STATISTICS_update (s->env->stats,
+                            net->stat_active,
+                            -1,
+                            GNUNET_NO);
+  GNUNET_assert (s->active_addresses > 0);
   s->active_addresses--;
-  GNUNET_STATISTICS_update(s->env->stats,
-                           "# ATS addresses total",
-                           -1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (s->env->stats,
+                            "# ATS addresses total",
+                            -1,
+                            GNUNET_NO);
 }
 
 
@@ -671,16 +679,16 @@ address_decrement_active(struct GAS_PROPORTIONAL_Handle *s,
  * @return #GNUNET_NO on double active address else #GNUNET_YES;
  */
 static int
-get_active_address_it(void *cls,
-                      const struct GNUNET_PeerIdentity *key,
-                      void *value)
+get_active_address_it (void *cls,
+                       const struct GNUNET_PeerIdentity *key,
+                       void *value)
 {
   struct ATS_Address **dest = cls;
   struct ATS_Address *aa = value;
 
   if (GNUNET_YES != aa->active)
     return GNUNET_OK;
-  GNUNET_assert(NULL == (*dest));
+  GNUNET_assert (NULL == (*dest));
   (*dest) = aa;
   return GNUNET_OK;
 }
@@ -694,16 +702,16 @@ get_active_address_it(void *cls,
  * @return active address or NULL
  */
 static struct ATS_Address *
-get_active_address(struct GAS_PROPORTIONAL_Handle *s,
-                   const struct GNUNET_PeerIdentity *peer)
+get_active_address (struct GAS_PROPORTIONAL_Handle *s,
+                    const struct GNUNET_PeerIdentity *peer)
 {
   struct ATS_Address *dest;
 
   dest = NULL;
-  GNUNET_CONTAINER_multipeermap_get_multiple(s->env->addresses,
-                                             peer,
-                                             &get_active_address_it,
-                                             &dest);
+  GNUNET_CONTAINER_multipeermap_get_multiple (s->env->addresses,
+                                              peer,
+                                              &get_active_address_it,
+                                              &dest);
   return dest;
 }
 
@@ -719,9 +727,9 @@ get_active_address(struct GAS_PROPORTIONAL_Handle *s,
  * @param peer the peer to check
  */
 static void
-update_active_address(struct GAS_PROPORTIONAL_Handle *s,
-                      struct ATS_Address *current_address,
-                      const struct GNUNET_PeerIdentity *peer)
+update_active_address (struct GAS_PROPORTIONAL_Handle *s,
+                       struct ATS_Address *current_address,
+                       const struct GNUNET_PeerIdentity *peer)
 {
   struct ATS_Address *best_address;
   struct AddressWrapper *asi_cur;
@@ -731,9 +739,9 @@ update_active_address(struct GAS_PROPORTIONAL_Handle *s,
   unsigned int a_con;
   unsigned int con_min;
 
-  best_address = get_best_address(s,
-                                  s->env->addresses,
-                                  peer);
+  best_address = get_best_address (s,
+                                   s->env->addresses,
+                                   peer);
   if (NULL != best_address)
     asi_best = best_address->solver_information;
   else
@@ -741,98 +749,98 @@ update_active_address(struct GAS_PROPORTIONAL_Handle *s,
   if (current_address == best_address)
     return; /* no changes */
   if (NULL != current_address)
+  {
+    /* We switch to a new address (or to none);
+       mark old address as inactive. */
+    asi_cur = current_address->solver_information;
+    GNUNET_assert (GNUNET_YES == current_address->active);
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Disabling previous active address for peer `%s'\n",
+         GNUNET_i2s (peer));
+    asi_cur->activated = GNUNET_TIME_UNIT_ZERO_ABS;
+    current_address->active = GNUNET_NO;
+    current_address->assigned_bw_in = 0;
+    current_address->assigned_bw_out = 0;
+    address_decrement_active (s,
+                              asi_cur->network);
+    if ((NULL == best_address) ||
+        (asi_best->network != asi_cur->network))
+      distribute_bandwidth_in_network (s,
+                                       asi_cur->network);
+    if (NULL == best_address)
     {
-      /* We switch to a new address (or to none);
-         mark old address as inactive. */
-      asi_cur = current_address->solver_information;
-      GNUNET_assert(GNUNET_YES == current_address->active);
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Disabling previous active address for peer `%s'\n",
-          GNUNET_i2s(peer));
-      asi_cur->activated = GNUNET_TIME_UNIT_ZERO_ABS;
-      current_address->active = GNUNET_NO;
-      current_address->assigned_bw_in = 0;
-      current_address->assigned_bw_out = 0;
-      address_decrement_active(s,
-                               asi_cur->network);
-      if ((NULL == best_address) ||
-          (asi_best->network != asi_cur->network))
-        distribute_bandwidth_in_network(s,
-                                        asi_cur->network);
-      if (NULL == best_address)
-        {
-          /* We previously had an active address, but now we cannot
-           * suggest one.  Therefore we have to disconnect the peer.
-           * The above call to "distribute_bandwidth_in_network()
-           * does not see 'current_address' so we need to trigger
-           * the update here. */
-          LOG(GNUNET_ERROR_TYPE_DEBUG,
-              "Disconnecting peer `%s'.\n",
-              GNUNET_i2s(peer));
-          s->env->bandwidth_changed_cb(s->env->cls,
-                                       current_address);
-          return;
-        }
-    }
-  if (NULL == best_address)
-    {
-      /* We do not have a new address, so we are done. */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Cannot suggest address for peer `%s'\n",
-          GNUNET_i2s(peer));
+      /* We previously had an active address, but now we cannot
+       * suggest one.  Therefore we have to disconnect the peer.
+       * The above call to "distribute_bandwidth_in_network()
+       * does not see 'current_address' so we need to trigger
+       * the update here. */
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Disconnecting peer `%s'.\n",
+           GNUNET_i2s (peer));
+      s->env->bandwidth_changed_cb (s->env->cls,
+                                    current_address);
       return;
     }
+  }
+  if (NULL == best_address)
+  {
+    /* We do not have a new address, so we are done. */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Cannot suggest address for peer `%s'\n",
+         GNUNET_i2s (peer));
+    return;
+  }
   /* We do have a new address, activate it */
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Selecting new address %p for peer `%s'\n",
-      best_address,
-      GNUNET_i2s(peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Selecting new address %p for peer `%s'\n",
+       best_address,
+       GNUNET_i2s (peer));
   /* Mark address as active */
   best_address->active = GNUNET_YES;
-  asi_best->activated = GNUNET_TIME_absolute_get();
+  asi_best->activated = GNUNET_TIME_absolute_get ();
   asi_best->network->active_addresses++;
   s->active_addresses++;
-  GNUNET_STATISTICS_update(s->env->stats,
-                           "# ATS active addresses total",
-                           1,
-                           GNUNET_NO);
-  GNUNET_STATISTICS_update(s->env->stats,
-                           asi_best->network->stat_active,
-                           1,
-                           GNUNET_NO);
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "Address %p for peer `%s' is now active\n",
-      best_address,
-      GNUNET_i2s(peer));
+  GNUNET_STATISTICS_update (s->env->stats,
+                            "# ATS active addresses total",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (s->env->stats,
+                            asi_best->network->stat_active,
+                            1,
+                            GNUNET_NO);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Address %p for peer `%s' is now active\n",
+       best_address,
+       GNUNET_i2s (peer));
 
   if (GNUNET_NO ==
-      is_bandwidth_available_in_network(asi_best->network,
-                                        0))
+      is_bandwidth_available_in_network (asi_best->network,
+                                         0))
+  {
+    /* we went over the maximum number of addresses for
+       this scope; remove the address with the smallest
+       connectivity requirement */
+    con_min = UINT32_MAX;
+    aw_min = NULL;
+    for (aw = asi_best->network->head; NULL != aw; aw = aw->next)
     {
-      /* we went over the maximum number of addresses for
-         this scope; remove the address with the smallest
-         connectivity requirement */
-      con_min = UINT32_MAX;
-      aw_min = NULL;
-      for (aw = asi_best->network->head; NULL != aw; aw = aw->next)
-        {
-          if ((con_min >
-               (a_con = s->env->get_connectivity(s->env->cls,
-                                                 &aw->addr->peer))) &&
-              (GNUNET_YES == aw->addr->active))
-            {
-              aw_min = aw;
-              con_min = a_con;
-              if (0 == con_min)
-                break;
-            }
-        }
-      update_active_address(s,
-                            aw_min->addr,
-                            &aw_min->addr->peer);
+      if ((con_min >
+           (a_con = s->env->get_connectivity (s->env->cls,
+                                              &aw->addr->peer))) &&
+          (GNUNET_YES == aw->addr->active))
+      {
+        aw_min = aw;
+        con_min = a_con;
+        if (0 == con_min)
+          break;
+      }
     }
-  distribute_bandwidth_in_network(s,
-                                  asi_best->network);
+    update_active_address (s,
+                           aw_min->addr,
+                           &aw_min->addr->peer);
+  }
+  distribute_bandwidth_in_network (s,
+                                   asi_best->network);
 }
 
 
@@ -845,17 +853,17 @@ update_active_address(struct GAS_PROPORTIONAL_Handle *s,
  * @param pref_rel the normalized preference value for this kind over all clients
  */
 static void
-GAS_proportional_change_preference(void *solver,
-                                   const struct GNUNET_PeerIdentity *peer,
-                                   enum GNUNET_ATS_PreferenceKind kind,
-                                   double pref_rel)
+GAS_proportional_change_preference (void *solver,
+                                    const struct GNUNET_PeerIdentity *peer,
+                                    enum GNUNET_ATS_PreferenceKind kind,
+                                    double pref_rel)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
 
   if (GNUNET_ATS_PREFERENCE_BANDWIDTH != kind)
     return; /* we do not care */
-  distribute_bandwidth_in_network(s,
-                                  NULL);
+  distribute_bandwidth_in_network (s,
+                                   NULL);
 }
 
 
@@ -870,12 +878,12 @@ GAS_proportional_change_preference(void *solver,
  * @param score the score
  */
 static void
-GAS_proportional_feedback(void *solver,
-                          struct GNUNET_SERVICE_Client *application,
-                          const struct GNUNET_PeerIdentity *peer,
-                          const struct GNUNET_TIME_Relative scope,
-                          enum GNUNET_ATS_PreferenceKind kind,
-                          double score)
+GAS_proportional_feedback (void *solver,
+                           struct GNUNET_SERVICE_Client *application,
+                           const struct GNUNET_PeerIdentity *peer,
+                           const struct GNUNET_TIME_Relative scope,
+                           enum GNUNET_ATS_PreferenceKind kind,
+                           double score)
 {
   /* Proportional does not care about feedback */
 }
@@ -888,15 +896,15 @@ GAS_proportional_feedback(void *solver,
  * @param peer the identity of the peer
  */
 static void
-GAS_proportional_start_get_address(void *solver,
-                                   const struct GNUNET_PeerIdentity *peer)
+GAS_proportional_start_get_address (void *solver,
+                                    const struct GNUNET_PeerIdentity *peer)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
 
-  update_active_address(s,
-                        get_active_address(s,
-                                           peer),
-                        peer);
+  update_active_address (s,
+                         get_active_address (s,
+                                             peer),
+                         peer);
 }
 
 
@@ -907,20 +915,20 @@ GAS_proportional_start_get_address(void *solver,
  * @param peer the peer
  */
 static void
-GAS_proportional_stop_get_address(void *solver,
-                                  const struct GNUNET_PeerIdentity *peer)
+GAS_proportional_stop_get_address (void *solver,
+                                   const struct GNUNET_PeerIdentity *peer)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
   struct ATS_Address *cur;
   struct AddressWrapper *asi;
 
-  cur = get_active_address(s,
-                           peer);
+  cur = get_active_address (s,
+                            peer);
   if (NULL == cur)
     return;
   asi = cur->solver_information;
-  distribute_bandwidth_in_network(s,
-                                  asi->network);
+  distribute_bandwidth_in_network (s,
+                                   asi->network);
 }
 
 
@@ -930,13 +938,13 @@ GAS_proportional_stop_get_address(void *solver,
  * @param solver the solver
  */
 static void
-GAS_proportional_bulk_start(void *solver)
+GAS_proportional_bulk_start (void *solver)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Locking solver for bulk operation ...\n");
-  GNUNET_assert(NULL != solver);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Locking solver for bulk operation ...\n");
+  GNUNET_assert (NULL != solver);
   s->bulk_lock++;
 }
 
@@ -947,27 +955,27 @@ GAS_proportional_bulk_start(void *solver)
  * @param solver our `struct GAS_PROPORTIONAL_Handle *`
  */
 static void
-GAS_proportional_bulk_stop(void *solver)
+GAS_proportional_bulk_stop (void *solver)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Unlocking solver from bulk operation ...\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Unlocking solver from bulk operation ...\n");
   if (s->bulk_lock < 1)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   s->bulk_lock--;
   if ((0 == s->bulk_lock) &&
       (0 < s->bulk_requests))
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "No lock pending, recalculating\n");
-      distribute_bandwidth_in_network(s,
-                                      NULL);
-      s->bulk_requests = 0;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "No lock pending, recalculating\n");
+    distribute_bandwidth_in_network (s,
+                                     NULL);
+    s->bulk_requests = 0;
+  }
 }
 
 
@@ -978,14 +986,14 @@ GAS_proportional_bulk_stop(void *solver)
  * @param address the address
  */
 static void
-GAS_proportional_address_property_changed(void *solver,
-                                          struct ATS_Address *address)
+GAS_proportional_address_property_changed (void *solver,
+                                           struct ATS_Address *address)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
   struct AddressWrapper *asi = address->solver_information;
 
-  distribute_bandwidth_in_network(s,
-                                  asi->network);
+  distribute_bandwidth_in_network (s,
+                                   asi->network);
 }
 
 
@@ -997,43 +1005,43 @@ GAS_proportional_address_property_changed(void *solver,
  * @param network network type of this address
  */
 static void
-GAS_proportional_address_add(void *solver,
-                             struct ATS_Address *address,
-                             uint32_t network)
+GAS_proportional_address_add (void *solver,
+                              struct ATS_Address *address,
+                              uint32_t network)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
   struct Network *net;
   struct AddressWrapper *aw;
 
-  GNUNET_assert(network < s->env->network_count);
+  GNUNET_assert (network < s->env->network_count);
   net = &s->network_entries[network];
   net->total_addresses++;
 
-  aw = GNUNET_new(struct AddressWrapper);
+  aw = GNUNET_new (struct AddressWrapper);
   aw->addr = address;
   aw->network = net;
   address->solver_information = aw;
-  GNUNET_CONTAINER_DLL_insert(net->head,
-                              net->tail,
-                              aw);
-  GNUNET_STATISTICS_update(s->env->stats,
-                           "# ATS addresses total",
-                           1,
-                           GNUNET_NO);
-  GNUNET_STATISTICS_update(s->env->stats,
-                           net->stat_total,
-                           1,
-                           GNUNET_NO);
-  update_active_address(s,
-                        get_active_address(s,
-                                           &address->peer),
-                        &address->peer);
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "Added new address for `%s', now total %u and active %u addresses in network `%s'\n",
-      GNUNET_i2s(&address->peer),
-      net->total_addresses,
-      net->active_addresses,
-      net->desc);
+  GNUNET_CONTAINER_DLL_insert (net->head,
+                               net->tail,
+                               aw);
+  GNUNET_STATISTICS_update (s->env->stats,
+                            "# ATS addresses total",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (s->env->stats,
+                            net->stat_total,
+                            1,
+                            GNUNET_NO);
+  update_active_address (s,
+                         get_active_address (s,
+                                             &address->peer),
+                         &address->peer);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Added new address for `%s', now total %u and active %u addresses in network `%s'\n",
+       GNUNET_i2s (&address->peer),
+       net->total_addresses,
+       net->active_addresses,
+       net->desc);
 }
 
 
@@ -1049,45 +1057,45 @@ GAS_proportional_address_add(void *solver,
  * @param address the address to remove
  */
 static void
-GAS_proportional_address_delete(void *solver,
-                                struct ATS_Address *address)
+GAS_proportional_address_delete (void *solver,
+                                 struct ATS_Address *address)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
   struct AddressWrapper *aw = address->solver_information;
   struct Network *net = aw->network;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Deleting %s address for peer `%s' from network `%s' (total: %u/active: %u)\n",
-      (GNUNET_NO == address->active) ? "inactive" : "active",
-      GNUNET_i2s(&address->peer),
-      net->desc,
-      net->total_addresses,
-      net->active_addresses);
-
-  GNUNET_CONTAINER_DLL_remove(net->head,
-                              net->tail,
-                              aw);
-  GNUNET_assert(net->total_addresses > 0);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Deleting %s address for peer `%s' from network `%s' (total: %u/active: %u)\n",
+       (GNUNET_NO == address->active) ? "inactive" : "active",
+       GNUNET_i2s (&address->peer),
+       net->desc,
+       net->total_addresses,
+       net->active_addresses);
+
+  GNUNET_CONTAINER_DLL_remove (net->head,
+                               net->tail,
+                               aw);
+  GNUNET_assert (net->total_addresses > 0);
   net->total_addresses--;
-  GNUNET_STATISTICS_update(s->env->stats,
-                           net->stat_total,
-                           -1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (s->env->stats,
+                            net->stat_total,
+                            -1,
+                            GNUNET_NO);
   if (GNUNET_YES == address->active)
-    {
-      /* Address was active, remove from network and update quotas */
-      update_active_address(s,
-                            address,
-                            &address->peer);
-      distribute_bandwidth_in_network(s, net);
-    }
-  GNUNET_free(aw);
+  {
+    /* Address was active, remove from network and update quotas */
+    update_active_address (s,
+                           address,
+                           &address->peer);
+    distribute_bandwidth_in_network (s, net);
+  }
+  GNUNET_free (aw);
   address->solver_information = NULL;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "After deleting address now total %u and active %u addresses in network `%s'\n",
-      net->total_addresses,
-      net->active_addresses,
-      net->desc);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "After deleting address now total %u and active %u addresses in network `%s'\n",
+       net->total_addresses,
+       net->active_addresses,
+       net->desc);
 }
 
 
@@ -1099,16 +1107,16 @@ GAS_proportional_address_delete(void *solver,
  * @return the `struct GAS_PROPORTIONAL_Handle` to pass as a closure
  */
 void *
-libgnunet_plugin_ats_proportional_init(void *cls)
+libgnunet_plugin_ats_proportional_init (void *cls)
 {
   static struct GNUNET_ATS_SolverFunctions sf;
   struct GNUNET_ATS_PluginEnvironment *env = cls;
   struct GAS_PROPORTIONAL_Handle *s;
-  struct Network * cur;
+  struct Network *cur;
   float f_tmp;
   unsigned int c;
 
-  s = GNUNET_new(struct GAS_PROPORTIONAL_Handle);
+  s = GNUNET_new (struct GAS_PROPORTIONAL_Handle);
   s->env = env;
   sf.cls = s;
   sf.s_add = &GAS_proportional_address_add;
@@ -1122,73 +1130,73 @@ libgnunet_plugin_ats_proportional_init(void *cls)
   sf.s_bulk_stop = &GAS_proportional_bulk_stop;
   s->stability_factor = PROP_STABILITY_FACTOR;
   if (GNUNET_SYSERR !=
-      GNUNET_CONFIGURATION_get_value_float(env->cfg,
-                                           "ats",
-                                           "PROP_STABILITY_FACTOR",
-                                           &f_tmp))
+      GNUNET_CONFIGURATION_get_value_float (env->cfg,
+                                            "ats",
+                                            "PROP_STABILITY_FACTOR",
+                                            &f_tmp))
+  {
+    if ((f_tmp < 1.0) || (f_tmp > 2.0))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Invalid %s configuration %f \n"),
+           "PROP_STABILITY_FACTOR",
+           f_tmp);
+    }
+    else
     {
-      if ((f_tmp < 1.0) || (f_tmp > 2.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR,
-              _("Invalid %s configuration %f \n"),
-              "PROP_STABILITY_FACTOR",
-              f_tmp);
-        }
-      else
-        {
-          s->stability_factor = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              "Using %s of %.3f\n",
-              "PROP_STABILITY_FACTOR",
-              f_tmp);
-        }
+      s->stability_factor = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           "Using %s of %.3f\n",
+           "PROP_STABILITY_FACTOR",
+           f_tmp);
     }
+  }
   s->prop_factor = PROPORTIONALITY_FACTOR;
   if (GNUNET_SYSERR !=
-      GNUNET_CONFIGURATION_get_value_float(env->cfg,
-                                           "ats",
-                                           "PROP_PROPORTIONALITY_FACTOR",
-                                           &f_tmp))
+      GNUNET_CONFIGURATION_get_value_float (env->cfg,
+                                            "ats",
+                                            "PROP_PROPORTIONALITY_FACTOR",
+                                            &f_tmp))
+  {
+    if (f_tmp < 1.0)
     {
-      if (f_tmp < 1.0)
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR,
-              _("Invalid %s configuration %f\n"),
-              "PROP_PROPORTIONALITY_FACTOR",
-              f_tmp);
-        }
-      else
-        {
-          s->prop_factor = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              "Using %s of %.3f\n",
-              "PROP_PROPORTIONALITY_FACTOR",
-              f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Invalid %s configuration %f\n"),
+           "PROP_PROPORTIONALITY_FACTOR",
+           f_tmp);
     }
-
-  s->network_entries = GNUNET_malloc(env->network_count *
-                                     sizeof(struct Network));
-  for (c = 0; c < env->network_count; c++)
+    else
     {
-      cur = &s->network_entries[c];
-      cur->type = c;
-      cur->total_quota_in = env->in_quota[c];
-      cur->total_quota_out = env->out_quota[c];
-      cur->desc = GNUNET_NT_to_string(c);
-      GNUNET_asprintf(&cur->stat_total,
-                      "# ATS addresses %s total",
-                      cur->desc);
-      GNUNET_asprintf(&cur->stat_active,
-                      "# ATS active addresses %s total",
-                      cur->desc);
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "Added network %u `%s' (%llu/%llu)\n",
-          c,
-          cur->desc,
-          cur->total_quota_in,
-          cur->total_quota_out);
+      s->prop_factor = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           "Using %s of %.3f\n",
+           "PROP_PROPORTIONALITY_FACTOR",
+           f_tmp);
     }
+  }
+
+  s->network_entries = GNUNET_malloc (env->network_count
+                                      * sizeof(struct Network));
+  for (c = 0; c < env->network_count; c++)
+  {
+    cur = &s->network_entries[c];
+    cur->type = c;
+    cur->total_quota_in = env->in_quota[c];
+    cur->total_quota_out = env->out_quota[c];
+    cur->desc = GNUNET_NT_to_string (c);
+    GNUNET_asprintf (&cur->stat_total,
+                     "# ATS addresses %s total",
+                     cur->desc);
+    GNUNET_asprintf (&cur->stat_active,
+                     "# ATS active addresses %s total",
+                     cur->desc);
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Added network %u `%s' (%llu/%llu)\n",
+         c,
+         cur->desc,
+         cur->total_quota_in,
+         cur->total_quota_out);
+  }
   return &sf;
 }
 
@@ -1199,7 +1207,7 @@ libgnunet_plugin_ats_proportional_init(void *cls)
  * @param cls return value from #libgnunet_plugin_ats_proportional_init()
  */
 void *
-libgnunet_plugin_ats_proportional_done(void *cls)
+libgnunet_plugin_ats_proportional_done (void *cls)
 {
   struct GNUNET_ATS_SolverFunctions *sf = cls;
   struct GAS_PROPORTIONAL_Handle *s = sf->cls;
@@ -1208,25 +1216,25 @@ libgnunet_plugin_ats_proportional_done(void *cls)
   unsigned int c;
 
   for (c = 0; c < s->env->network_count; c++)
+  {
+    GNUNET_break (0 == s->network_entries[c].total_addresses);
+    GNUNET_break (0 == s->network_entries[c].active_addresses);
+    next = s->network_entries[c].head;
+    while (NULL != (cur = next))
     {
-      GNUNET_break(0 == s->network_entries[c].total_addresses);
-      GNUNET_break(0 == s->network_entries[c].active_addresses);
-      next = s->network_entries[c].head;
-      while (NULL != (cur = next))
-        {
-          next = cur->next;
-          GNUNET_CONTAINER_DLL_remove(s->network_entries[c].head,
-                                      s->network_entries[c].tail,
-                                      cur);
-          GNUNET_free_non_null(cur->addr->solver_information);
-          GNUNET_free(cur);
-        }
-      GNUNET_free(s->network_entries[c].stat_total);
-      GNUNET_free(s->network_entries[c].stat_active);
+      next = cur->next;
+      GNUNET_CONTAINER_DLL_remove (s->network_entries[c].head,
+                                   s->network_entries[c].tail,
+                                   cur);
+      GNUNET_free_non_null (cur->addr->solver_information);
+      GNUNET_free (cur);
     }
-  GNUNET_break(0 == s->active_addresses);
-  GNUNET_free(s->network_entries);
-  GNUNET_free(s);
+    GNUNET_free (s->network_entries[c].stat_total);
+    GNUNET_free (s->network_entries[c].stat_active);
+  }
+  GNUNET_break (0 == s->active_addresses);
+  GNUNET_free (s->network_entries);
+  GNUNET_free (s);
   return NULL;
 }
 
diff --git a/src/ats/plugin_ats_ril.c b/src/ats/plugin_ats_ril.c
index abf265f19..7be3cb0a1 100644
--- a/src/ats/plugin_ats_ril.c
+++ b/src/ats/plugin_ats_ril.c
@@ -32,17 +32,21 @@
 
 
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "ats-ril", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "ats-ril", __VA_ARGS__)
 
-#define RIL_MIN_BW                      (5 * ntohl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__))
+#define RIL_MIN_BW                      (5 * ntohl ( \
+                                           GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT. \
+                                           value__))
 #define RIL_MAX_BW                      GNUNET_ATS_MaxBandwidth
 
 #define RIL_ACTION_INVALID              -1
 #define RIL_INTERVAL_EXPONENT           10
 #define RIL_UTILITY_DELAY_MAX           1000
 
-#define RIL_DEFAULT_STEP_TIME_MIN       GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200)
-#define RIL_DEFAULT_STEP_TIME_MAX       GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 2000)
+#define RIL_DEFAULT_STEP_TIME_MIN       GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MILLISECONDS, 200)
+#define RIL_DEFAULT_STEP_TIME_MAX       GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MILLISECONDS, 2000)
 #define RIL_DEFAULT_ALGORITHM           RIL_ALGO_SARSA
 #define RIL_DEFAULT_SELECT              RIL_SELECT_SOFTMAX
 #define RIL_DEFAULT_WELFARE             RIL_WELFARE_NASH
@@ -71,9 +75,10 @@
  * to a particular address. The action of switching to address with index i is depicted by the
  * number (RIL_ACTION_TYPE_NUM + i).
  */
-enum RIL_Action_Type {
+enum RIL_Action_Type
+{
   RIL_ACTION_NOTHING = 0,
-  RIL_ACTION_BW_IN_DBL = -2, //TODO? Potentially add more actions
+  RIL_ACTION_BW_IN_DBL = -2, // TODO? Potentially add more actions
   RIL_ACTION_BW_IN_HLV = -3,
   RIL_ACTION_BW_IN_INC = 1,
   RIL_ACTION_BW_IN_DEC = 2,
@@ -84,22 +89,26 @@ enum RIL_Action_Type {
   RIL_ACTION_TYPE_NUM = 5
 };
 
-enum RIL_Algorithm {
+enum RIL_Algorithm
+{
   RIL_ALGO_SARSA = 0,
   RIL_ALGO_Q = 1
 };
 
-enum RIL_Select {
+enum RIL_Select
+{
   RIL_SELECT_SOFTMAX = 0,
   RIL_SELECT_EGREEDY = 1
 };
 
-enum RIL_Welfare {
+enum RIL_Welfare
+{
   RIL_WELFARE_NASH,
   RIL_WELFARE_EGALITARIAN
 };
 
-enum RIL_E_Modification {
+enum RIL_E_Modification
+{
   RIL_E_DECAY,
   RIL_E_ZERO,
   RIL_E_ACCUMULATE,
@@ -109,7 +118,8 @@ enum RIL_E_Modification {
 /**
  * Global learning parameters
  */
-struct RIL_Learning_Parameters {
+struct RIL_Learning_Parameters
+{
   /**
    * The TD-algorithm to use
    */
@@ -199,7 +209,8 @@ struct RIL_Learning_Parameters {
 /**
  * Wrapper for addresses to store them in agent's linked list
  */
-struct RIL_Address_Wrapped {
+struct RIL_Address_Wrapped
+{
   /**
    * Next in DLL
    */
@@ -217,7 +228,8 @@ struct RIL_Address_Wrapped {
 };
 
 
-struct RIL_Peer_Agent {
+struct RIL_Peer_Agent
+{
   /**
    * Next agent in solver's linked list
    */
@@ -251,7 +263,7 @@ struct RIL_Peer_Agent {
   /**
    * Experience matrix W
    */
-  double ** W;
+  double **W;
 
   /**
    * Number of rows of W / Number of state-vector features
@@ -276,7 +288,7 @@ struct RIL_Peer_Agent {
   /**
    * Eligibility traces
    */
-  double ** E;
+  double **E;
 
   /**
    * Whether to reset the eligibility traces to 0 after a Q-exploration step
@@ -329,7 +341,8 @@ struct RIL_Peer_Agent {
   double nop_bonus;
 };
 
-struct RIL_Scope {
+struct RIL_Scope
+{
   /**
    * ATS network type
    */
@@ -379,7 +392,8 @@ struct RIL_Scope {
 /**
  * A handle for the reinforcement learning solver
  */
-struct GAS_RIL_Handle {
+struct GAS_RIL_Handle
+{
   /**
    * The solver-plugin environment of the solver-plugin API
    */
@@ -398,7 +412,7 @@ struct GAS_RIL_Handle {
   /**
    * Task identifier of the next time-step to be executed
    */
-  struct GNUNET_SCHEDULER_Task * step_next_task_id;
+  struct GNUNET_SCHEDULER_Task *step_next_task_id;
 
   /**
    * Variable discount factor, dependent on time between steps
@@ -428,7 +442,7 @@ struct GAS_RIL_Handle {
   /**
    * Array of networks with global assignment state
    */
-  struct RIL_Scope * network_entries;
+  struct RIL_Scope *network_entries;
 
   /**
    * Networks count
@@ -438,8 +452,8 @@ struct GAS_RIL_Handle {
   /**
    * List of active peer-agents
    */
-  struct RIL_Peer_Agent * agents_head;
-  struct RIL_Peer_Agent * agents_tail;
+  struct RIL_Peer_Agent *agents_head;
+  struct RIL_Peer_Agent *agents_tail;
 
   /**
    * Shutdown
@@ -466,9 +480,9 @@ struct GAS_RIL_Handle {
  * @return estimation value
  */
 static double
-agent_q(struct RIL_Peer_Agent *agent,
-        const double *state,
-        int action)
+agent_q (struct RIL_Peer_Agent *agent,
+         const double *state,
+         int action)
 {
   unsigned int i;
   double result = 0.0;
@@ -477,10 +491,10 @@ agent_q(struct RIL_Peer_Agent *agent,
     result += state[i] * agent->W[action][i];
 
   /* prevent crashes if learning diverges */
-  if (isnan(result))
-    return isnan(result) * UINT32_MAX;
-  if (isinf(result))
-    return isinf(result) * UINT32_MAX;
+  if (isnan (result))
+    return isnan (result) * UINT32_MAX;
+  if (isinf (result))
+    return isinf (result) * UINT32_MAX;
   return result;
 }
 
@@ -493,18 +507,19 @@ agent_q(struct RIL_Peer_Agent *agent,
  * @return the index, starting with zero
  */
 static int
-agent_address_get_index(struct RIL_Peer_Agent *agent, struct ATS_Address *address)
+agent_address_get_index (struct RIL_Peer_Agent *agent, struct
+                         ATS_Address *address)
 {
   int i;
   struct RIL_Address_Wrapped *cur;
 
   i = -1;
   for (cur = agent->addresses_head; NULL != cur; cur = cur->next)
-    {
-      i++;
-      if (cur->address_naked == address)
-        return i;
-    }
+  {
+    i++;
+    if (cur->address_naked == address)
+      return i;
+  }
   return i;
 }
 
@@ -517,7 +532,8 @@ agent_address_get_index(struct RIL_Peer_Agent *agent, struct ATS_Address *addres
  * @return wrapped address
  */
 static struct RIL_Address_Wrapped *
-agent_address_get_wrapped(struct RIL_Peer_Agent *agent, struct ATS_Address *address)
+agent_address_get_wrapped (struct RIL_Peer_Agent *agent, struct
+                           ATS_Address *address)
 {
   struct RIL_Address_Wrapped *cur;
 
@@ -529,67 +545,70 @@ agent_address_get_wrapped(struct RIL_Peer_Agent *agent, struct ATS_Address *addr
 
 
 static int
-agent_action_is_possible(struct RIL_Peer_Agent *agent, int action)
+agent_action_is_possible (struct RIL_Peer_Agent *agent, int action)
 {
   int address_index;
 
   switch (action)
-    {
-    case RIL_ACTION_NOTHING:
+  {
+  case RIL_ACTION_NOTHING:
+    return GNUNET_YES;
+    break;
+
+  case RIL_ACTION_BW_IN_INC:
+  case RIL_ACTION_BW_IN_DBL:
+    if (agent->bw_in >= RIL_MAX_BW)
+      return GNUNET_NO;
+    else
       return GNUNET_YES;
-      break;
+    break;
 
-    case RIL_ACTION_BW_IN_INC:
-    case RIL_ACTION_BW_IN_DBL:
-      if (agent->bw_in >= RIL_MAX_BW)
-        return GNUNET_NO;
-      else
-        return GNUNET_YES;
-      break;
+  case RIL_ACTION_BW_IN_DEC:
+  case RIL_ACTION_BW_IN_HLV:
+    if (agent->bw_in <= 0)
+      return GNUNET_NO;
+    else
+      return GNUNET_YES;
+    break;
 
-    case RIL_ACTION_BW_IN_DEC:
-    case RIL_ACTION_BW_IN_HLV:
-      if (agent->bw_in <= 0)
-        return GNUNET_NO;
-      else
-        return GNUNET_YES;
-      break;
+  case RIL_ACTION_BW_OUT_INC:
+  case RIL_ACTION_BW_OUT_DBL:
+    if (agent->bw_out >= RIL_MAX_BW)
+      return GNUNET_NO;
+    else
+      return GNUNET_YES;
+    break;
 
-    case RIL_ACTION_BW_OUT_INC:
-    case RIL_ACTION_BW_OUT_DBL:
-      if (agent->bw_out >= RIL_MAX_BW)
-        return GNUNET_NO;
-      else
-        return GNUNET_YES;
-      break;
+  case RIL_ACTION_BW_OUT_DEC:
+  case RIL_ACTION_BW_OUT_HLV:
+    if (agent->bw_out <= 0)
+      return GNUNET_NO;
+    else
+      return GNUNET_YES;
+    break;
 
-    case RIL_ACTION_BW_OUT_DEC:
-    case RIL_ACTION_BW_OUT_HLV:
-      if (agent->bw_out <= 0)
+  default:
+    if ((action >= RIL_ACTION_TYPE_NUM) && (action < agent->n))   // switch address action
+    {
+      address_index = action - RIL_ACTION_TYPE_NUM;
+
+      GNUNET_assert (address_index >= 0);
+      GNUNET_assert (
+        address_index <= agent_address_get_index (agent,
+                                                  agent->addresses_tail->
+                                                  address_naked));
+
+      if ((agent_address_get_index (agent, agent->address_inuse) ==
+           address_index) ||
+          agent->address_inuse->active)
         return GNUNET_NO;
       else
         return GNUNET_YES;
       break;
-
-    default:
-      if ((action >= RIL_ACTION_TYPE_NUM) && (action < agent->n)) //switch address action
-        {
-          address_index = action - RIL_ACTION_TYPE_NUM;
-
-          GNUNET_assert(address_index >= 0);
-          GNUNET_assert(
-            address_index <= agent_address_get_index(agent, agent->addresses_tail->address_naked));
-
-          if ((agent_address_get_index(agent, agent->address_inuse) == address_index) ||
-              agent->address_inuse->active)
-            return GNUNET_NO;
-          else
-            return GNUNET_YES;
-          break;
-        }
-      // error - action does not exist
-      GNUNET_assert(GNUNET_NO);
     }
+    // error - action does not exist
+    GNUNET_assert (GNUNET_NO);
+  }
 }
 
 
@@ -602,7 +621,7 @@ agent_action_is_possible(struct RIL_Peer_Agent *agent, int action)
  * @return the action promising most future reward
  */
 static int
-agent_get_action_max(struct RIL_Peer_Agent *agent, double *state)
+agent_get_action_max (struct RIL_Peer_Agent *agent, double *state)
 {
   int i;
   int max_i = RIL_ACTION_INVALID;
@@ -610,19 +629,19 @@ agent_get_action_max(struct RIL_Peer_Agent *agent, double *state)
   double max_q = -DBL_MAX;
 
   for (i = 0; i < agent->n; i++)
+  {
+    if (agent_action_is_possible (agent, i))
     {
-      if (agent_action_is_possible(agent, i))
-        {
-          cur_q = agent_q(agent, state, i);
-          if (cur_q > max_q)
-            {
-              max_q = cur_q;
-              max_i = i;
-            }
-        }
+      cur_q = agent_q (agent, state, i);
+      if (cur_q > max_q)
+      {
+        max_q = cur_q;
+        max_i = i;
+      }
     }
+  }
 
-  GNUNET_assert(RIL_ACTION_INVALID != max_i);
+  GNUNET_assert (RIL_ACTION_INVALID != max_i);
 
   return max_i;
 }
@@ -634,7 +653,7 @@ agent_get_action_max(struct RIL_Peer_Agent *agent, double *state)
  * @return the action index
  */
 static int
-agent_get_action_random(struct RIL_Peer_Agent *agent)
+agent_get_action_random (struct RIL_Peer_Agent *agent)
 {
   int i;
   int is_possible[agent->n];
@@ -642,32 +661,32 @@ agent_get_action_random(struct RIL_Peer_Agent *agent)
   int r;
 
   for (i = 0; i < agent->n; i++)
+  {
+    if (agent_action_is_possible (agent, i))
     {
-      if (agent_action_is_possible(agent, i))
-        {
-          is_possible[i] = GNUNET_YES;
-          sum++;
-        }
-      else
-        {
-          is_possible[i] = GNUNET_NO;
-        }
+      is_possible[i] = GNUNET_YES;
+      sum++;
+    }
+    else
+    {
+      is_possible[i] = GNUNET_NO;
     }
+  }
 
-  r = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, sum);
+  r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, sum);
 
   sum = -1;
   for (i = 0; i < agent->n; i++)
+  {
+    if (is_possible[i])
     {
-      if (is_possible[i])
-        {
-          sum++;
-          if (sum == r)
-            return i;
-        }
+      sum++;
+      if (sum == r)
+        return i;
     }
+  }
 
-  GNUNET_assert(GNUNET_NO);
+  GNUNET_assert (GNUNET_NO);
   return RIL_ACTION_INVALID;
 }
 
@@ -681,16 +700,18 @@ agent_get_action_random(struct RIL_Peer_Agent *agent)
  * @param a_prime the new
  */
 static void
-agent_update(struct RIL_Peer_Agent *agent, double reward, double *s_next, int a_prime)
+agent_update (struct RIL_Peer_Agent *agent, double reward, double *s_next, int
+              a_prime)
 {
   int i;
   int k;
   double delta;
   double **theta = agent->W;
 
-  delta = agent->envi->global_discount_integrated * reward; //reward
-  delta += agent->envi->global_discount_variable * agent_q(agent, s_next, a_prime);  //discounted future value
-  delta -= agent_q(agent, agent->s_old, agent->a_old);  //one step
+  delta = agent->envi->global_discount_integrated * reward; // reward
+  delta += agent->envi->global_discount_variable * agent_q (agent, s_next,
+                                                            a_prime);                // discounted future value
+  delta -= agent_q (agent, agent->s_old, agent->a_old);  // one step
 
 //  LOG(GNUNET_ERROR_TYPE_INFO, "update()   Step# %llu  Q(s,a): %f  a: %f  r: %f  y: %f  Q(s+1,a+1) = %f  delta: %f\n",
 //      agent->step_count,
@@ -702,17 +723,17 @@ agent_update(struct RIL_Peer_Agent *agent, double reward, double *s_next, int a_
 //      delta);
 
   for (k = 0; k < agent->n; k++)
+  {
+    for (i = 0; i < agent->m; i++)
     {
-      for (i = 0; i < agent->m; i++)
-        {
-          //    LOG(GNUNET_ERROR_TYPE_INFO, "alpha = %f   delta = %f   e[%d] = %f\n",
-          //        agent->envi->parameters.alpha,
-          //        delta,
-          //        i,
-          //        agent->e[i]);
-          theta[k][i] += agent->envi->parameters.alpha * delta * agent->E[k][i];
-        }
+      //    LOG(GNUNET_ERROR_TYPE_INFO, "alpha = %f   delta = %f   e[%d] = %f\n",
+      //        agent->envi->parameters.alpha,
+      //        delta,
+      //        i,
+      //        agent->e[i]);
+      theta[k][i] += agent->envi->parameters.alpha * delta * agent->E[k][i];
     }
+  }
 }
 
 
@@ -729,41 +750,43 @@ agent_update(struct RIL_Peer_Agent *agent, double reward, double *s_next, int a_
  * @param action the action to take
  */
 static void
-agent_modify_eligibility(struct RIL_Peer_Agent *agent,
-                         enum RIL_E_Modification mod,
-                         double *feature,
-                         int action)
+agent_modify_eligibility (struct RIL_Peer_Agent *agent,
+                          enum RIL_E_Modification mod,
+                          double *feature,
+                          int action)
 {
   int i;
   int k;
 
   for (i = 0; i < agent->m; i++)
+  {
+    switch (mod)
     {
-      switch (mod)
-        {
-        case RIL_E_ACCUMULATE:
-          agent->E[action][i] += feature[i];
-          break;
-
-        case RIL_E_REPLACE:
-          agent->E[action][i] = agent->E[action][i] > feature[i] ? agent->E[action][i] : feature[i];
-          break;
-
-        case RIL_E_DECAY:
-          for (k = 0; k < agent->n; k++)
-            {
-              agent->E[k][i] *= agent->envi->global_discount_variable * agent->envi->parameters.lambda;
-            }
-          break;
-
-        case RIL_E_ZERO:
-          for (k = 0; k < agent->n; k++)
-            {
-              agent->E[k][i] = 0;
-            }
-          break;
-        }
+    case RIL_E_ACCUMULATE:
+      agent->E[action][i] += feature[i];
+      break;
+
+    case RIL_E_REPLACE:
+      agent->E[action][i] = agent->E[action][i] > feature[i] ?
+                            agent->E[action][i] : feature[i];
+      break;
+
+    case RIL_E_DECAY:
+      for (k = 0; k < agent->n; k++)
+      {
+        agent->E[k][i] *= agent->envi->global_discount_variable
+                          * agent->envi->parameters.lambda;
+      }
+      break;
+
+    case RIL_E_ZERO:
+      for (k = 0; k < agent->n; k++)
+      {
+        agent->E[k][i] = 0;
+      }
+      break;
     }
+  }
 }
 
 /**
@@ -774,14 +797,14 @@ agent_modify_eligibility(struct RIL_Peer_Agent *agent,
  * @param stat
  */
 static void
-ril_inform(struct GAS_RIL_Handle *solver,
-           enum GAS_Solver_Operation op,
-           enum GAS_Solver_Status stat)
-{
-  solver->env->info_cb(solver->env->cls,
-                       op,
-                       stat,
-                       GAS_INFO_NONE);
+ril_inform (struct GAS_RIL_Handle *solver,
+            enum GAS_Solver_Operation op,
+            enum GAS_Solver_Status stat)
+{
+  solver->env->info_cb (solver->env->cls,
+                        op,
+                        stat,
+                        GAS_INFO_NONE);
 }
 
 /**
@@ -790,9 +813,11 @@ ril_inform(struct GAS_RIL_Handle *solver,
  * @param net
  */
 static unsigned long long
-ril_get_max_bw(struct RIL_Scope *net)
+ril_get_max_bw (struct RIL_Scope *net)
 {
-  return GNUNET_MIN(2 * GNUNET_MAX(net->bw_in_available, net->bw_out_available), GNUNET_ATS_MaxBandwidth);
+  return GNUNET_MIN (2 * GNUNET_MAX (net->bw_in_available,
+                                     net->bw_out_available),
+                     GNUNET_ATS_MaxBandwidth);
 }
 
 /**
@@ -807,82 +832,84 @@ ril_get_max_bw(struct RIL_Scope *net)
  * @param silent disables invocation of the bw_changed callback, if #GNUNET_YES
  */
 static void
-envi_set_active_suggestion(struct GAS_RIL_Handle *solver,
-                           struct RIL_Peer_Agent *agent,
-                           struct ATS_Address *new_address,
-                           unsigned long long new_bw_in,
-                           unsigned long long new_bw_out,
-                           int silent)
+envi_set_active_suggestion (struct GAS_RIL_Handle *solver,
+                            struct RIL_Peer_Agent *agent,
+                            struct ATS_Address *new_address,
+                            unsigned long long new_bw_in,
+                            unsigned long long new_bw_out,
+                            int silent)
 {
   int notify = GNUNET_NO;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "    set_active_suggestion() for peer '%s'\n",
-      GNUNET_i2s(&agent->peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "    set_active_suggestion() for peer '%s'\n",
+       GNUNET_i2s (&agent->peer));
 
-  //address change
+  // address change
   if (agent->address_inuse != new_address)
+  {
+    if (NULL != agent->address_inuse)
     {
-      if (NULL != agent->address_inuse)
-        {
-          agent->address_inuse->active = GNUNET_NO;
-          agent->address_inuse->assigned_bw_in = 0;
-          agent->address_inuse->assigned_bw_out = 0;
-        }
-      if (NULL != new_address)
-        {
-          LOG(GNUNET_ERROR_TYPE_DEBUG, "    set address active: %s\n", agent->is_active ? "yes" : "no");
-          new_address->active = agent->is_active;
-          new_address->assigned_bw_in = agent->bw_in;
-          new_address->assigned_bw_out = agent->bw_out;
-        }
-      notify |= GNUNET_YES;
+      agent->address_inuse->active = GNUNET_NO;
+      agent->address_inuse->assigned_bw_in = 0;
+      agent->address_inuse->assigned_bw_out = 0;
+    }
+    if (NULL != new_address)
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "    set address active: %s\n",
+           agent->is_active ? "yes" : "no");
+      new_address->active = agent->is_active;
+      new_address->assigned_bw_in = agent->bw_in;
+      new_address->assigned_bw_out = agent->bw_out;
     }
+    notify |= GNUNET_YES;
+  }
 
   if (new_address)
+  {
+    // activity change
+    if (new_address->active != agent->is_active)
     {
-      //activity change
-      if (new_address->active != agent->is_active)
-        {
-          new_address->active = agent->is_active;
-          notify |= GNUNET_YES;
-        }
-
-      //bw change
-      if (agent->bw_in != new_bw_in)
-        {
-          agent->bw_in = new_bw_in;
-          new_address->assigned_bw_in = new_bw_in;
-          notify |= GNUNET_YES;
-        }
-      if (agent->bw_out != new_bw_out)
-        {
-          agent->bw_out = new_bw_out;
-          new_address->assigned_bw_out = new_bw_out;
-          notify |= GNUNET_YES;
-        }
+      new_address->active = agent->is_active;
+      notify |= GNUNET_YES;
     }
 
+    // bw change
+    if (agent->bw_in != new_bw_in)
+    {
+      agent->bw_in = new_bw_in;
+      new_address->assigned_bw_in = new_bw_in;
+      notify |= GNUNET_YES;
+    }
+    if (agent->bw_out != new_bw_out)
+    {
+      agent->bw_out = new_bw_out;
+      new_address->assigned_bw_out = new_bw_out;
+      notify |= GNUNET_YES;
+    }
+  }
+
   if (notify && agent->is_active && (GNUNET_NO == silent))
+  {
+    if (new_address)
     {
-      if (new_address)
-        {
-          LOG(GNUNET_ERROR_TYPE_DEBUG, "    envi_set_active_suggestion() notify\n");
-          agent->suggestion_issue = GNUNET_YES;
-          agent->suggestion_address = new_address;
-        }
-      else if (agent->address_inuse)
-        {
-          /* disconnect case, no new address */
-          GNUNET_assert(0 == agent->address_inuse->assigned_bw_in);
-          GNUNET_assert(0 == agent->address_inuse->assigned_bw_out);
-          agent->bw_in = 0;
-          agent->bw_out = 0;
-
-          agent->suggestion_issue = GNUNET_YES;
-          agent->suggestion_address = agent->address_inuse;
-        }
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "    envi_set_active_suggestion() notify\n");
+      agent->suggestion_issue = GNUNET_YES;
+      agent->suggestion_address = new_address;
     }
+    else if (agent->address_inuse)
+    {
+      /* disconnect case, no new address */
+      GNUNET_assert (0 == agent->address_inuse->assigned_bw_in);
+      GNUNET_assert (0 == agent->address_inuse->assigned_bw_out);
+      agent->bw_in = 0;
+      agent->bw_out = 0;
+
+      agent->suggestion_issue = GNUNET_YES;
+      agent->suggestion_address = agent->address_inuse;
+    }
+  }
   agent->address_inuse = new_address;
 }
 
@@ -894,7 +921,7 @@ envi_set_active_suggestion(struct GAS_RIL_Handle *solver,
  * @return pointer to the state vector
  */
 static double *
-envi_get_state(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
+envi_get_state (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
 {
   double *state;
   double y[2];
@@ -907,27 +934,34 @@ envi_get_state(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
   int k;
   unsigned long long max_bw;
 
-  state = GNUNET_malloc(sizeof(double) * agent->m);
+  state = GNUNET_malloc (sizeof(double) * agent->m);
 
-  max_bw = ril_get_max_bw((struct RIL_Scope *)agent->address_inuse->solver_information);
+  max_bw = ril_get_max_bw ((struct
+                            RIL_Scope *) agent->address_inuse->
+                           solver_information);
 
-  y[0] = (double)agent->bw_out;
-  y[1] = (double)agent->bw_in;
+  y[0] = (double) agent->bw_out;
+  y[1] = (double) agent->bw_in;
 
-  m = agent_address_get_index(agent, agent->address_inuse) * (solver->parameters.rbf_divisor + 1) * (solver->parameters.rbf_divisor + 1);
+  m = agent_address_get_index (agent, agent->address_inuse)
+      * (solver->parameters.rbf_divisor + 1) * (solver->parameters.rbf_divisor
+                                                + 1);
   for (i = 0; i <= solver->parameters.rbf_divisor; i++)
-    {
-      for (k = 0; k <= solver->parameters.rbf_divisor; k++)
-        {
-          x[0] = (double)i * (double)max_bw / (double)solver->parameters.rbf_divisor;
-          x[1] = (double)k * (double)max_bw / (double)solver->parameters.rbf_divisor;
-          d[0] = x[0] - y[0];
-          d[1] = x[1] - y[1];
-          sigma = (((double)max_bw / ((double)solver->parameters.rbf_divisor + 1)) * 0.5);
-          f = exp(-((d[0] * d[0] + d[1] * d[1]) / (2 * sigma * sigma)));
-          state[m++] = f;
-        }
-    }
+  {
+    for (k = 0; k <= solver->parameters.rbf_divisor; k++)
+    {
+      x[0] = (double) i * (double) max_bw
+             / (double) solver->parameters.rbf_divisor;
+      x[1] = (double) k * (double) max_bw
+             / (double) solver->parameters.rbf_divisor;
+      d[0] = x[0] - y[0];
+      d[1] = x[1] - y[1];
+      sigma = (((double) max_bw / ((double) solver->parameters.rbf_divisor
+                                   + 1)) * 0.5);
+      f = exp (-((d[0] * d[0] + d[1] * d[1]) / (2 * sigma * sigma)));
+      state[m++] = f;
+    }
+  }
 
   return state;
 }
@@ -940,22 +974,23 @@ envi_get_state(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
  * @return the utility value
  */
 static double
-agent_get_utility(struct RIL_Peer_Agent *agent)
+agent_get_utility (struct RIL_Peer_Agent *agent)
 {
   const double *preferences;
   double delay_atsi;
   double delay_norm;
   double pref_match;
 
-  preferences = agent->envi->env->get_preferences(agent->envi->env->cls,
-                                                  &agent->peer);
+  preferences = agent->envi->env->get_preferences (agent->envi->env->cls,
+                                                   &agent->peer);
 
   delay_atsi = agent->address_inuse->norm_delay.norm;
-  delay_norm = RIL_UTILITY_DELAY_MAX * exp(-delay_atsi * 0.00001);
+  delay_norm = RIL_UTILITY_DELAY_MAX * exp (-delay_atsi * 0.00001);
 
   pref_match = preferences[GNUNET_ATS_PREFERENCE_LATENCY] * delay_norm;
-  pref_match += preferences[GNUNET_ATS_PREFERENCE_BANDWIDTH] *
-                sqrt((double)(agent->bw_in / RIL_MIN_BW) * (double)(agent->bw_out / RIL_MIN_BW));
+  pref_match += preferences[GNUNET_ATS_PREFERENCE_BANDWIDTH]
+                * sqrt ((double) (agent->bw_in / RIL_MIN_BW)
+                        * (double) (agent->bw_out / RIL_MIN_BW));
   return pref_match;
 }
 
@@ -968,41 +1003,45 @@ agent_get_utility(struct RIL_Peer_Agent *agent)
  * @return the social welfare value
  */
 static double
-ril_network_get_social_welfare(struct GAS_RIL_Handle *solver, struct RIL_Scope *scope)
+ril_network_get_social_welfare (struct GAS_RIL_Handle *solver, struct
+                                RIL_Scope *scope)
 {
   struct RIL_Peer_Agent *cur;
   double result;
 
   switch (solver->parameters.social_welfare)
-    {
-    case RIL_WELFARE_EGALITARIAN:
-      result = DBL_MAX;
-      for (cur = solver->agents_head; NULL != cur; cur = cur->next)
-        {
-          if (cur->is_active && cur->address_inuse && (cur->address_inuse->solver_information == scope))
-            {
-              result = GNUNET_MIN(result, agent_get_utility(cur));
-            }
-        }
-      return result;
-
-    case RIL_WELFARE_NASH:
-      result = 0;
-      for (cur = solver->agents_head; NULL != cur; cur = cur->next)
-        {
-          if (cur->is_active && cur->address_inuse && (cur->address_inuse->solver_information == scope))
-            {
-              result *= pow(agent_get_utility(cur), 1.0 / (double)scope->active_agent_count);
-            }
-        }
-      return result;
-    }
-  GNUNET_assert(GNUNET_NO);
+  {
+  case RIL_WELFARE_EGALITARIAN:
+    result = DBL_MAX;
+    for (cur = solver->agents_head; NULL != cur; cur = cur->next)
+    {
+      if (cur->is_active && cur->address_inuse &&
+          (cur->address_inuse->solver_information == scope))
+      {
+        result = GNUNET_MIN (result, agent_get_utility (cur));
+      }
+    }
+    return result;
+
+  case RIL_WELFARE_NASH:
+    result = 0;
+    for (cur = solver->agents_head; NULL != cur; cur = cur->next)
+    {
+      if (cur->is_active && cur->address_inuse &&
+          (cur->address_inuse->solver_information == scope))
+      {
+        result *= pow (agent_get_utility (cur), 1.0
+                       / (double) scope->active_agent_count);
+      }
+    }
+    return result;
+  }
+  GNUNET_assert (GNUNET_NO);
   return 1;
 }
 
 static double
-envi_get_penalty(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
+envi_get_penalty (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
 {
   struct RIL_Scope *net;
   unsigned long long over_max;
@@ -1012,26 +1051,26 @@ envi_get_penalty(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
   net = agent->address_inuse->solver_information;
 
   if (net->bw_in_utilized > net->bw_in_available)
+  {
+    over_in = net->bw_in_utilized - net->bw_in_available;
+    if (RIL_ACTION_BW_IN_INC == agent->a_old)
     {
-      over_in = net->bw_in_utilized - net->bw_in_available;
-      if (RIL_ACTION_BW_IN_INC == agent->a_old)
-        {
-          /* increase quadratically */
-          over_in *= over_in;
-        }
+      /* increase quadratically */
+      over_in *= over_in;
     }
+  }
   if (net->bw_out_utilized > net->bw_out_available)
+  {
+    over_out = net->bw_out_utilized - net->bw_out_available;
+    if (RIL_ACTION_BW_OUT_INC == agent->a_old)
     {
-      over_out = net->bw_out_utilized - net->bw_out_available;
-      if (RIL_ACTION_BW_OUT_INC == agent->a_old)
-        {
-          /* increase quadratically */
-          over_out *= over_out;
-        }
+      /* increase quadratically */
+      over_out *= over_out;
     }
+  }
   over_max = (over_in + over_out) / (RIL_MIN_BW * RIL_MIN_BW);
 
-  return -1.0 * (double)over_max;
+  return -1.0 * (double) over_max;
 }
 
 /**
@@ -1044,7 +1083,7 @@ envi_get_penalty(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
  * @return the reward
  */
 static double
-envi_get_reward(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
+envi_get_reward (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
 {
   struct RIL_Scope *net;
   double objective;
@@ -1055,19 +1094,19 @@ envi_get_reward(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
 
   net = agent->address_inuse->solver_information;
 
-  penalty = envi_get_penalty(solver, agent);
-  objective = (agent_get_utility(agent) + net->social_welfare) / 2;
+  penalty = envi_get_penalty (solver, agent);
+  objective = (agent_get_utility (agent) + net->social_welfare) / 2;
   delta = objective - agent->objective_old;
   agent->objective_old = objective;
 
-  if (delta != 0 && penalty == 0)
-    {
-      agent->nop_bonus = delta * RIL_NOP_DECAY;
-    }
+  if ((delta != 0)&&(penalty == 0))
+  {
+    agent->nop_bonus = delta * RIL_NOP_DECAY;
+  }
   else
-    {
-      agent->nop_bonus *= RIL_NOP_DECAY;
-    }
+  {
+    agent->nop_bonus *= RIL_NOP_DECAY;
+  }
 
   steady = (RIL_ACTION_NOTHING == agent->a_old) ? agent->nop_bonus : 0;
 
@@ -1083,31 +1122,34 @@ envi_get_reward(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
  * @param direction_in if GNUNET_YES, change inbound bandwidth, otherwise the outbound bandwidth
  */
 static void
-envi_action_bw_double(struct GAS_RIL_Handle *solver,
-                      struct RIL_Peer_Agent *agent,
-                      int direction_in)
+envi_action_bw_double (struct GAS_RIL_Handle *solver,
+                       struct RIL_Peer_Agent *agent,
+                       int direction_in)
 {
   unsigned long long new_bw;
   unsigned long long max_bw;
 
-  max_bw = ril_get_max_bw((struct RIL_Scope *)agent->address_inuse->solver_information);
+  max_bw = ril_get_max_bw ((struct
+                            RIL_Scope *) agent->address_inuse->
+                           solver_information);
 
   if (direction_in)
-    {
-      new_bw = agent->bw_in * 2;
-      if (new_bw < agent->bw_in || new_bw > max_bw)
-        new_bw = max_bw;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, new_bw,
-                                 agent->bw_out, GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_in * 2;
+    if ((new_bw < agent->bw_in) ||(new_bw > max_bw) )
+      new_bw = max_bw;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse, new_bw,
+                                agent->bw_out, GNUNET_NO);
+  }
   else
-    {
-      new_bw = agent->bw_out * 2;
-      if (new_bw < agent->bw_out || new_bw > max_bw)
-        new_bw = max_bw;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, agent->bw_in,
-                                 new_bw, GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_out * 2;
+    if ((new_bw < agent->bw_out) ||(new_bw > max_bw) )
+      new_bw = max_bw;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse,
+                                agent->bw_in,
+                                new_bw, GNUNET_NO);
+  }
 }
 
 /**
@@ -1120,28 +1162,30 @@ envi_action_bw_double(struct GAS_RIL_Handle *solver,
  * bandwidth
  */
 static void
-envi_action_bw_halven(struct GAS_RIL_Handle *solver,
-                      struct RIL_Peer_Agent *agent,
-                      int direction_in)
+envi_action_bw_halven (struct GAS_RIL_Handle *solver,
+                       struct RIL_Peer_Agent *agent,
+                       int direction_in)
 {
   unsigned long long new_bw;
 
   if (direction_in)
-    {
-      new_bw = agent->bw_in / 2;
-      if (new_bw <= 0 || new_bw > agent->bw_in)
-        new_bw = 0;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, new_bw, agent->bw_out,
-                                 GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_in / 2;
+    if ((new_bw <= 0) ||(new_bw > agent->bw_in) )
+      new_bw = 0;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse, new_bw,
+                                agent->bw_out,
+                                GNUNET_NO);
+  }
   else
-    {
-      new_bw = agent->bw_out / 2;
-      if (new_bw <= 0 || new_bw > agent->bw_out)
-        new_bw = 0;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, agent->bw_in, new_bw,
-                                 GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_out / 2;
+    if ((new_bw <= 0) ||(new_bw > agent->bw_out) )
+      new_bw = 0;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse,
+                                agent->bw_in, new_bw,
+                                GNUNET_NO);
+  }
 }
 
 /**
@@ -1153,29 +1197,33 @@ envi_action_bw_halven(struct GAS_RIL_Handle *solver,
  * bandwidth
  */
 static void
-envi_action_bw_inc(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent, int direction_in)
+envi_action_bw_inc (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent,
+                    int direction_in)
 {
   unsigned long long new_bw;
   unsigned long long max_bw;
 
-  max_bw = ril_get_max_bw((struct RIL_Scope *)agent->address_inuse->solver_information);
+  max_bw = ril_get_max_bw ((struct
+                            RIL_Scope *) agent->address_inuse->
+                           solver_information);
 
   if (direction_in)
-    {
-      new_bw = agent->bw_in + (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
-      if (new_bw < agent->bw_in || new_bw > max_bw)
-        new_bw = max_bw;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, new_bw,
-                                 agent->bw_out, GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_in + (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
+    if ((new_bw < agent->bw_in) ||(new_bw > max_bw) )
+      new_bw = max_bw;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse, new_bw,
+                                agent->bw_out, GNUNET_NO);
+  }
   else
-    {
-      new_bw = agent->bw_out + (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
-      if (new_bw < agent->bw_out || new_bw > max_bw)
-        new_bw = max_bw;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, agent->bw_in,
-                                 new_bw, GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_out + (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
+    if ((new_bw < agent->bw_out) ||(new_bw > max_bw) )
+      new_bw = max_bw;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse,
+                                agent->bw_in,
+                                new_bw, GNUNET_NO);
+  }
 }
 
 /**
@@ -1188,26 +1236,29 @@ envi_action_bw_inc(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent,
  * bandwidth
  */
 static void
-envi_action_bw_dec(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent, int direction_in)
+envi_action_bw_dec (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent,
+                    int direction_in)
 {
   unsigned long long new_bw;
 
   if (direction_in)
-    {
-      new_bw = agent->bw_in - (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
-      if (new_bw <= 0 || new_bw > agent->bw_in)
-        new_bw = 0;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, new_bw, agent->bw_out,
-                                 GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_in - (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
+    if ((new_bw <= 0) ||(new_bw > agent->bw_in) )
+      new_bw = 0;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse, new_bw,
+                                agent->bw_out,
+                                GNUNET_NO);
+  }
   else
-    {
-      new_bw = agent->bw_out - (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
-      if (new_bw <= 0 || new_bw > agent->bw_out)
-        new_bw = 0;
-      envi_set_active_suggestion(solver, agent, agent->address_inuse, agent->bw_in, new_bw,
-                                 GNUNET_NO);
-    }
+  {
+    new_bw = agent->bw_out - (RIL_INC_DEC_STEP_SIZE * RIL_MIN_BW);
+    if ((new_bw <= 0) ||(new_bw > agent->bw_out) )
+      new_bw = 0;
+    envi_set_active_suggestion (solver, agent, agent->address_inuse,
+                                agent->bw_in, new_bw,
+                                GNUNET_NO);
+  }
 }
 
 /**
@@ -1218,29 +1269,30 @@ envi_action_bw_dec(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent,
  * @param address_index index of the address as it is saved in the agent's list, starting with zero
  */
 static void
-envi_action_address_switch(struct GAS_RIL_Handle *solver,
-                           struct RIL_Peer_Agent *agent,
-                           unsigned int address_index)
+envi_action_address_switch (struct GAS_RIL_Handle *solver,
+                            struct RIL_Peer_Agent *agent,
+                            unsigned int address_index)
 {
   struct RIL_Address_Wrapped *cur;
   int i = 0;
 
-  //cur = agent_address_get_wrapped(agent, agent->address_inuse);
+  // cur = agent_address_get_wrapped(agent, agent->address_inuse);
 
   for (cur = agent->addresses_head; NULL != cur; cur = cur->next)
+  {
+    if (i == address_index)
     {
-      if (i == address_index)
-        {
-          envi_set_active_suggestion(solver, agent, cur->address_naked, agent->bw_in, agent->bw_out,
-                                     GNUNET_NO);
-          return;
-        }
-
-      i++;
+      envi_set_active_suggestion (solver, agent, cur->address_naked,
+                                  agent->bw_in, agent->bw_out,
+                                  GNUNET_NO);
+      return;
     }
 
-  //no address with address_index exists, in this case this action should not be callable
-  GNUNET_assert(GNUNET_NO);
+    i++;
+  }
+
+  // no address with address_index exists, in this case this action should not be callable
+  GNUNET_assert (GNUNET_NO);
 }
 
 /**
@@ -1251,62 +1303,65 @@ envi_action_address_switch(struct GAS_RIL_Handle *solver,
  * @param action the action to perform by the solver
  */
 static void
-envi_do_action(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent, int action)
+envi_do_action (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent, int
+                action)
 {
   int address_index;
 
   switch (action)
-    {
-    case RIL_ACTION_NOTHING:
-      break;
+  {
+  case RIL_ACTION_NOTHING:
+    break;
 
-    case RIL_ACTION_BW_IN_DBL:
-      envi_action_bw_double(solver, agent, GNUNET_YES);
-      break;
+  case RIL_ACTION_BW_IN_DBL:
+    envi_action_bw_double (solver, agent, GNUNET_YES);
+    break;
 
-    case RIL_ACTION_BW_IN_HLV:
-      envi_action_bw_halven(solver, agent, GNUNET_YES);
-      break;
+  case RIL_ACTION_BW_IN_HLV:
+    envi_action_bw_halven (solver, agent, GNUNET_YES);
+    break;
 
-    case RIL_ACTION_BW_IN_INC:
-      envi_action_bw_inc(solver, agent, GNUNET_YES);
-      break;
+  case RIL_ACTION_BW_IN_INC:
+    envi_action_bw_inc (solver, agent, GNUNET_YES);
+    break;
 
-    case RIL_ACTION_BW_IN_DEC:
-      envi_action_bw_dec(solver, agent, GNUNET_YES);
-      break;
+  case RIL_ACTION_BW_IN_DEC:
+    envi_action_bw_dec (solver, agent, GNUNET_YES);
+    break;
 
-    case RIL_ACTION_BW_OUT_DBL:
-      envi_action_bw_double(solver, agent, GNUNET_NO);
-      break;
+  case RIL_ACTION_BW_OUT_DBL:
+    envi_action_bw_double (solver, agent, GNUNET_NO);
+    break;
 
-    case RIL_ACTION_BW_OUT_HLV:
-      envi_action_bw_halven(solver, agent, GNUNET_NO);
-      break;
+  case RIL_ACTION_BW_OUT_HLV:
+    envi_action_bw_halven (solver, agent, GNUNET_NO);
+    break;
 
-    case RIL_ACTION_BW_OUT_INC:
-      envi_action_bw_inc(solver, agent, GNUNET_NO);
-      break;
+  case RIL_ACTION_BW_OUT_INC:
+    envi_action_bw_inc (solver, agent, GNUNET_NO);
+    break;
 
-    case RIL_ACTION_BW_OUT_DEC:
-      envi_action_bw_dec(solver, agent, GNUNET_NO);
-      break;
+  case RIL_ACTION_BW_OUT_DEC:
+    envi_action_bw_dec (solver, agent, GNUNET_NO);
+    break;
 
-    default:
-      if ((action >= RIL_ACTION_TYPE_NUM) && (action < agent->n)) //switch address action
-        {
-          address_index = action - RIL_ACTION_TYPE_NUM;
+  default:
+    if ((action >= RIL_ACTION_TYPE_NUM) && (action < agent->n))   // switch address action
+    {
+      address_index = action - RIL_ACTION_TYPE_NUM;
 
-          GNUNET_assert(address_index >= 0);
-          GNUNET_assert(
-            address_index <= agent_address_get_index(agent, agent->addresses_tail->address_naked));
+      GNUNET_assert (address_index >= 0);
+      GNUNET_assert (
+        address_index <= agent_address_get_index (agent,
+                                                  agent->addresses_tail->
+                                                  address_naked));
 
-          envi_action_address_switch(solver, agent, address_index);
-          break;
-        }
-      // error - action does not exist
-      GNUNET_assert(GNUNET_NO);
+      envi_action_address_switch (solver, agent, address_index);
+      break;
     }
+    // error - action does not exist
+    GNUNET_assert (GNUNET_NO);
+  }
 }
 
 /**
@@ -1321,27 +1376,28 @@ envi_do_action(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent, int
  * @return the action index
  */
 static int
-agent_select_egreedy(struct RIL_Peer_Agent *agent, double *state)
+agent_select_egreedy (struct RIL_Peer_Agent *agent, double *state)
 {
   int action;
-  double r = (double)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                              UINT32_MAX) / (double)UINT32_MAX;
-
-  if (r < agent->envi->parameters.epsilon) //explore
-    {
-      action = agent_get_action_random(agent);
-      if (RIL_ALGO_Q == agent->envi->parameters.algorithm)
-        {
-          agent->eligibility_reset = GNUNET_YES;
-        }
-      agent->envi->parameters.epsilon *= agent->envi->parameters.epsilon_decay;
-      return action;
-    }
-  else //exploit
-    {
-      action = agent_get_action_max(agent, state);
-      return action;
-    }
+  double r = (double) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                UINT32_MAX)
+             / (double) UINT32_MAX;
+
+  if (r < agent->envi->parameters.epsilon) // explore
+  {
+    action = agent_get_action_random (agent);
+    if (RIL_ALGO_Q == agent->envi->parameters.algorithm)
+    {
+      agent->eligibility_reset = GNUNET_YES;
+    }
+    agent->envi->parameters.epsilon *= agent->envi->parameters.epsilon_decay;
+    return action;
+  }
+  else // exploit
+  {
+    action = agent_get_action_max (agent, state);
+    return action;
+  }
 }
 
 /**
@@ -1355,7 +1411,7 @@ agent_select_egreedy(struct RIL_Peer_Agent *agent, double *state)
  * @return
  */
 static int
-agent_select_softmax(struct RIL_Peer_Agent *agent, double *state)
+agent_select_softmax (struct RIL_Peer_Agent *agent, double *state)
 {
   int i;
   int a_max;
@@ -1364,47 +1420,49 @@ agent_select_softmax(struct RIL_Peer_Agent *agent, double *state)
   double sum = 0;
   double r;
 
-  a_max = agent_get_action_max(agent, state);
+  a_max = agent_get_action_max (agent, state);
 
   for (i = 0; i < agent->n; i++)
+  {
+    if (agent_action_is_possible (agent, i))
     {
-      if (agent_action_is_possible(agent, i))
-        {
-          eqt[i] = exp(agent_q(agent, state, i) / agent->envi->parameters.temperature);
-          if (isinf(eqt[i]))
-            eqt[i] = isinf(eqt[i]) * UINT32_MAX;
-          sum += eqt[i];
-        }
+      eqt[i] = exp (agent_q (agent, state, i)
+                    / agent->envi->parameters.temperature);
+      if (isinf (eqt[i]))
+        eqt[i] = isinf (eqt[i]) * UINT32_MAX;
+      sum += eqt[i];
     }
+  }
   for (i = 0; i < agent->n; i++)
+  {
+    if (agent_action_is_possible (agent, i))
     {
-      if (agent_action_is_possible(agent, i))
-        {
-          p[i] = eqt[i] / sum;
-        }
-      else
-        {
-          p[i] = 0;
-        }
+      p[i] = eqt[i] / sum;
+    }
+    else
+    {
+      p[i] = 0;
     }
-  r = (double)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                       UINT32_MAX) / (double)UINT32_MAX;
+  }
+  r = (double) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                         UINT32_MAX) / (double) UINT32_MAX;
   sum = 0;
   for (i = 0; i < agent->n; i++)
+  {
+    if (sum + p[i] > r)
     {
-      if (sum + p[i] > r)
-        {
-          if (i != a_max)
-            {
-              if (RIL_ALGO_Q == agent->envi->parameters.algorithm)
-                agent->eligibility_reset = GNUNET_YES;
-              agent->envi->parameters.temperature *= agent->envi->parameters.temperature_decay;
-            }
-          return i;
-        }
-      sum += p[i];
-    }
-  GNUNET_assert(GNUNET_NO);
+      if (i != a_max)
+      {
+        if (RIL_ALGO_Q == agent->envi->parameters.algorithm)
+          agent->eligibility_reset = GNUNET_YES;
+        agent->envi->parameters.temperature *=
+          agent->envi->parameters.temperature_decay;
+      }
+      return i;
+    }
+    sum += p[i];
+  }
+  GNUNET_assert (GNUNET_NO);
   return RIL_ACTION_INVALID;
 }
 
@@ -1417,16 +1475,16 @@ agent_select_softmax(struct RIL_Peer_Agent *agent, double *state)
  * @return the action index
  */
 static int
-agent_select_action(struct RIL_Peer_Agent *agent, double *state)
+agent_select_action (struct RIL_Peer_Agent *agent, double *state)
 {
   if (agent->envi->parameters.select == RIL_SELECT_EGREEDY)
-    {
-      return agent_select_egreedy(agent, state);
-    }
+  {
+    return agent_select_egreedy (agent, state);
+  }
   else
-    {
-      return agent_select_softmax(agent, state);
-    }
+  {
+    return agent_select_softmax (agent, state);
+  }
 }
 
 /**
@@ -1438,68 +1496,71 @@ agent_select_action(struct RIL_Peer_Agent *agent, double *state)
  * @param agent the agent performing the step
  */
 static void
-agent_step(struct RIL_Peer_Agent *agent)
+agent_step (struct RIL_Peer_Agent *agent)
 {
   int a_next = RIL_ACTION_INVALID;
   int a_max;
   double *s_next;
   double reward;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "    agent_step() Peer '%s', algorithm %s\n",
-      GNUNET_i2s(&agent->peer),
-      agent->envi->parameters.algorithm ? "Q" : "SARSA");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "    agent_step() Peer '%s', algorithm %s\n",
+       GNUNET_i2s (&agent->peer),
+       agent->envi->parameters.algorithm ? "Q" : "SARSA");
 
-  s_next = envi_get_state(agent->envi, agent);
-  reward = envi_get_reward(agent->envi, agent);
+  s_next = envi_get_state (agent->envi, agent);
+  reward = envi_get_reward (agent->envi, agent);
 
   if (agent->eligibility_reset)
-    {
-      agent_modify_eligibility(agent, RIL_E_ZERO, NULL, -1);
-      agent->eligibility_reset = GNUNET_NO;
-    }
+  {
+    agent_modify_eligibility (agent, RIL_E_ZERO, NULL, -1);
+    agent->eligibility_reset = GNUNET_NO;
+  }
   else
-    {
-      agent_modify_eligibility(agent, RIL_E_DECAY, NULL, -1);
-    }
+  {
+    agent_modify_eligibility (agent, RIL_E_DECAY, NULL, -1);
+  }
   if (RIL_ACTION_INVALID != agent->a_old)
-    {
-      agent_modify_eligibility(agent, agent->envi->parameters.eligibility_trace_mode, agent->s_old, agent->a_old);
-    }
+  {
+    agent_modify_eligibility (agent,
+                              agent->envi->parameters.eligibility_trace_mode,
+                              agent->s_old, agent->a_old);
+  }
 
   switch (agent->envi->parameters.algorithm)
+  {
+  case RIL_ALGO_SARSA:
+    a_next = agent_select_action (agent, s_next);
+    if (RIL_ACTION_INVALID != agent->a_old)
     {
-    case RIL_ALGO_SARSA:
-      a_next = agent_select_action(agent, s_next);
-      if (RIL_ACTION_INVALID != agent->a_old)
-        {
-          //updates weights with selected action (on-policy), if not first step
-          agent_update(agent, reward, s_next, a_next);
-        }
-      break;
+      // updates weights with selected action (on-policy), if not first step
+      agent_update (agent, reward, s_next, a_next);
+    }
+    break;
 
-    case RIL_ALGO_Q:
-      a_max = agent_get_action_max(agent, s_next);
-      if (RIL_ACTION_INVALID != agent->a_old)
-        {
-          //updates weights with best action, disregarding actually selected action (off-policy), if not first step
-          agent_update(agent, reward, s_next, a_max);
-        }
-      a_next = agent_select_action(agent, s_next);
-      break;
+  case RIL_ALGO_Q:
+    a_max = agent_get_action_max (agent, s_next);
+    if (RIL_ACTION_INVALID != agent->a_old)
+    {
+      // updates weights with best action, disregarding actually selected action (off-policy), if not first step
+      agent_update (agent, reward, s_next, a_max);
     }
+    a_next = agent_select_action (agent, s_next);
+    break;
+  }
 
-  GNUNET_assert(RIL_ACTION_INVALID != a_next);
+  GNUNET_assert (RIL_ACTION_INVALID != a_next);
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "step()  Step# %llu  R: %f  IN %llu  OUT %llu  A: %d\n",
-      agent->step_count,
-      reward,
-      agent->bw_in / 1024,
-      agent->bw_out / 1024,
-      a_next);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "step()  Step# %llu  R: %f  IN %llu  OUT %llu  A: %d\n",
+       agent->step_count,
+       reward,
+       agent->bw_in / 1024,
+       agent->bw_out / 1024,
+       a_next);
 
-  envi_do_action(agent->envi, agent, a_next);
+  envi_do_action (agent->envi, agent, a_next);
 
-  GNUNET_free(agent->s_old);
+  GNUNET_free (agent->s_old);
   agent->s_old = s_next;
   agent->a_old = a_next;
 
@@ -1512,7 +1573,7 @@ agent_step(struct RIL_Peer_Agent *agent)
  * @param solver the solver handle
  */
 static void
-ril_step(struct GAS_RIL_Handle *solver);
+ril_step (struct GAS_RIL_Handle *solver);
 
 
 /**
@@ -1522,12 +1583,12 @@ ril_step(struct GAS_RIL_Handle *solver);
  * @param cls the solver handle
  */
 static void
-ril_step_scheduler_task(void *cls)
+ril_step_scheduler_task (void *cls)
 {
   struct GAS_RIL_Handle *solver = cls;
 
   solver->step_next_task_id = NULL;
-  ril_step(solver);
+  ril_step (solver);
 }
 
 /**
@@ -1539,7 +1600,7 @@ ril_step_scheduler_task(void *cls)
  * @return the ratio
  */
 static double
-ril_get_used_resource_ratio(struct GAS_RIL_Handle *solver)
+ril_get_used_resource_ratio (struct GAS_RIL_Handle *solver)
 {
   int i;
   struct RIL_Scope net;
@@ -1548,26 +1609,26 @@ ril_get_used_resource_ratio(struct GAS_RIL_Handle *solver)
   double ratio;
 
   for (i = 0; i < solver->networks_count; i++)
+  {
+    net = solver->network_entries[i];
+    if (net.bw_in_assigned > 0)   // only consider scopes where an address is actually active
     {
-      net = solver->network_entries[i];
-      if (net.bw_in_assigned > 0) //only consider scopes where an address is actually active
-        {
-          sum_assigned += net.bw_in_utilized;
-          sum_assigned += net.bw_out_utilized;
-          sum_available += net.bw_in_available;
-          sum_available += net.bw_out_available;
-        }
+      sum_assigned += net.bw_in_utilized;
+      sum_assigned += net.bw_out_utilized;
+      sum_available += net.bw_in_available;
+      sum_available += net.bw_out_available;
     }
+  }
   if (sum_available > 0)
-    {
-      ratio = ((double)sum_assigned) / ((double)sum_available);
-    }
+  {
+    ratio = ((double) sum_assigned) / ((double) sum_available);
+  }
   else
-    {
-      ratio = 0;
-    }
+  {
+    ratio = 0;
+  }
 
-  return ratio > 1 ? 1 : ratio; //overutilization is possible, cap at 1
+  return ratio > 1 ? 1 : ratio; // overutilization is possible, cap at 1
 }
 
 /**
@@ -1578,17 +1639,17 @@ ril_get_used_resource_ratio(struct GAS_RIL_Handle *solver)
  * @return the network struct
  */
 static struct RIL_Scope *
-ril_get_network(struct GAS_RIL_Handle *s, uint32_t type)
+ril_get_network (struct GAS_RIL_Handle *s, uint32_t type)
 {
   int i;
 
   for (i = 0; i < s->networks_count; i++)
+  {
+    if (s->network_entries[i].type == type)
     {
-      if (s->network_entries[i].type == type)
-        {
-          return &s->network_entries[i];
-        }
+      return &s->network_entries[i];
     }
+  }
   return NULL;
 }
 
@@ -1602,26 +1663,28 @@ ril_get_network(struct GAS_RIL_Handle *s, uint32_t type)
  * @return GNUNET_YES if there are theoretically enough resources left
  */
 static int
-ril_network_is_not_full(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType network)
+ril_network_is_not_full (struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType
+                         network)
 {
   struct RIL_Scope *net;
   struct RIL_Peer_Agent *agent;
   unsigned long long address_count = 0;
 
   for (agent = solver->agents_head; NULL != agent; agent = agent->next)
+  {
+    if (agent->address_inuse && agent->is_active)
     {
-      if (agent->address_inuse && agent->is_active)
-        {
-          net = agent->address_inuse->solver_information;
-          if (net->type == network)
-            {
-              address_count++;
-            }
-        }
+      net = agent->address_inuse->solver_information;
+      if (net->type == network)
+      {
+        address_count++;
+      }
     }
+  }
 
-  net = ril_get_network(solver, network);
-  return (net->bw_in_available > RIL_MIN_BW * address_count) && (net->bw_out_available > RIL_MIN_BW * address_count);
+  net = ril_get_network (solver, network);
+  return (net->bw_in_available > RIL_MIN_BW * address_count) &&
+         (net->bw_out_available > RIL_MIN_BW * address_count);
 }
 
 /**
@@ -1635,27 +1698,34 @@ ril_network_is_not_full(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType n
  * @param silent
  */
 static void
-ril_try_unblock_agent(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent, int silent)
+ril_try_unblock_agent (struct GAS_RIL_Handle *solver, struct
+                       RIL_Peer_Agent *agent, int silent)
 {
   struct RIL_Address_Wrapped *addr_wrap;
   struct RIL_Scope *net;
   unsigned long long start_in;
   unsigned long long start_out;
 
-  for (addr_wrap = agent->addresses_head; NULL != addr_wrap; addr_wrap = addr_wrap->next)
-    {
-      net = addr_wrap->address_naked->solver_information;
-      if (ril_network_is_not_full(solver, net->type))
-        {
-          if (NULL == agent->address_inuse)
-            {
-              start_in = net->bw_in_available < net->bw_in_utilized ? (net->bw_in_available - net->bw_in_utilized) / 2 : RIL_MIN_BW;
-              start_out = net->bw_out_available < net->bw_out_utilized ? (net->bw_out_available - net->bw_out_utilized) / 2 : RIL_MIN_BW;
-              envi_set_active_suggestion(solver, agent, addr_wrap->address_naked, start_in, start_out, silent);
-            }
-          return;
-        }
+  for (addr_wrap = agent->addresses_head; NULL != addr_wrap; addr_wrap =
+         addr_wrap->next)
+  {
+    net = addr_wrap->address_naked->solver_information;
+    if (ril_network_is_not_full (solver, net->type))
+    {
+      if (NULL == agent->address_inuse)
+      {
+        start_in = net->bw_in_available < net->bw_in_utilized ?
+                   (net->bw_in_available - net->bw_in_utilized) / 2 :
+                   RIL_MIN_BW;
+        start_out = net->bw_out_available < net->bw_out_utilized ?
+                    (net->bw_out_available - net->bw_out_utilized) / 2 :
+                    RIL_MIN_BW;
+        envi_set_active_suggestion (solver, agent, addr_wrap->address_naked,
+                                    start_in, start_out, silent);
+      }
+      return;
     }
+  }
   agent->address_inuse = NULL;
 }
 
@@ -1666,7 +1736,7 @@ ril_try_unblock_agent(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agen
  * @param solver the solver handle
  */
 static void
-ril_calculate_discount(struct GAS_RIL_Handle *solver)
+ril_calculate_discount (struct GAS_RIL_Handle *solver)
 {
   struct GNUNET_TIME_Absolute time_now;
   struct GNUNET_TIME_Relative time_delta;
@@ -1674,25 +1744,28 @@ ril_calculate_discount(struct GAS_RIL_Handle *solver)
 
   // MDP case only for debugging purposes
   if (solver->simulate)
-    {
-      solver->global_discount_variable = solver->parameters.gamma;
-      solver->global_discount_integrated = 1;
-      return;
-    }
+  {
+    solver->global_discount_variable = solver->parameters.gamma;
+    solver->global_discount_integrated = 1;
+    return;
+  }
 
   // semi-MDP case
 
-  //calculate tau, i.e. how many real valued time units have passed, one time unit is one minimum time step
-  time_now = GNUNET_TIME_absolute_get();
-  time_delta = GNUNET_TIME_absolute_get_difference(solver->step_time_last, time_now);
+  // calculate tau, i.e. how many real valued time units have passed, one time unit is one minimum time step
+  time_now = GNUNET_TIME_absolute_get ();
+  time_delta = GNUNET_TIME_absolute_get_difference (solver->step_time_last,
+                                                    time_now);
   solver->step_time_last = time_now;
-  tau = (double)time_delta.rel_value_us
-        / (double)solver->parameters.step_time_min.rel_value_us;
+  tau = (double) time_delta.rel_value_us
+        / (double) solver->parameters.step_time_min.rel_value_us;
 
-  //calculate reward discounts (once per step for all agents)
-  solver->global_discount_variable = pow(M_E, ((-1.0) * ((double)solver->parameters.beta) * tau));
+  // calculate reward discounts (once per step for all agents)
+  solver->global_discount_variable = pow (M_E, ((-1.0)
+                                                * ((double) solver->parameters.
+                                                   beta) * tau));
   solver->global_discount_integrated = (1.0 - solver->global_discount_variable)
-                                       / (double)solver->parameters.beta;
+                                       / (double) solver->parameters.beta;
 }
 
 /**
@@ -1703,18 +1776,21 @@ ril_calculate_discount(struct GAS_RIL_Handle *solver)
  * @return the number of allocated connections
  */
 static int
-ril_network_count_active_agents(struct GAS_RIL_Handle *solver, struct RIL_Scope *scope)
+ril_network_count_active_agents (struct GAS_RIL_Handle *solver, struct
+                                 RIL_Scope *scope)
 {
   int c = 0;
   struct RIL_Peer_Agent *cur_agent;
 
-  for (cur_agent = solver->agents_head; NULL != cur_agent; cur_agent = cur_agent->next)
+  for (cur_agent = solver->agents_head; NULL != cur_agent; cur_agent =
+         cur_agent->next)
+  {
+    if (cur_agent->is_active && cur_agent->address_inuse &&
+        (cur_agent->address_inuse->solver_information == scope))
     {
-      if (cur_agent->is_active && cur_agent->address_inuse && (cur_agent->address_inuse->solver_information == scope))
-        {
-          c++;
-        }
+      c++;
     }
+  }
   return c;
 }
 
@@ -1729,26 +1805,27 @@ ril_network_count_active_agents(struct GAS_RIL_Handle *solver, struct RIL_Scope
  * @return the sum of the assigned bandwidths
  */
 static unsigned long long
-ril_network_get_assigned(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType type, int direction_in)
+ril_network_get_assigned (struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType
+                          type, int direction_in)
 {
   struct RIL_Peer_Agent *cur;
   struct RIL_Scope *net;
   unsigned long long sum = 0;
 
   for (cur = solver->agents_head; NULL != cur; cur = cur->next)
+  {
+    if (cur->is_active && cur->address_inuse)
     {
-      if (cur->is_active && cur->address_inuse)
-        {
-          net = cur->address_inuse->solver_information;
-          if (net->type == type)
-            {
-              if (direction_in)
-                sum += cur->bw_in;
-              else
-                sum += cur->bw_out;
-            }
-        }
+      net = cur->address_inuse->solver_information;
+      if (net->type == type)
+      {
+        if (direction_in)
+          sum += cur->bw_in;
+        else
+          sum += cur->bw_out;
+      }
     }
+  }
 
   return sum;
 }
@@ -1764,26 +1841,27 @@ ril_network_get_assigned(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType
  * @return the sum of the utilized bandwidths (in bytes/second)
  */
 static unsigned long long
-ril_network_get_utilized(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType type, int direction_in)
+ril_network_get_utilized (struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType
+                          type, int direction_in)
 {
   struct RIL_Peer_Agent *cur;
   struct RIL_Scope *net;
   unsigned long long sum = 0;
 
   for (cur = solver->agents_head; NULL != cur; cur = cur->next)
+  {
+    if (cur->is_active && cur->address_inuse)
     {
-      if (cur->is_active && cur->address_inuse)
-        {
-          net = cur->address_inuse->solver_information;
-          if (net->type == type)
-            {
-              if (direction_in)
-                sum += cur->address_inuse->norm_utilization_in.norm;
-              else
-                sum += cur->address_inuse->norm_utilization_out.norm;
-            }
-        }
+      net = cur->address_inuse->solver_information;
+      if (net->type == type)
+      {
+        if (direction_in)
+          sum += cur->address_inuse->norm_utilization_in.norm;
+        else
+          sum += cur->address_inuse->norm_utilization_out.norm;
+      }
     }
+  }
 
   return sum;
 }
@@ -1795,21 +1873,25 @@ ril_network_get_utilized(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType
  * @param solver the solver handle
  */
 static void
-ril_networks_update_state(struct GAS_RIL_Handle *solver)
+ril_networks_update_state (struct GAS_RIL_Handle *solver)
 {
   int c;
   struct RIL_Scope *net;
 
   for (c = 0; c < solver->networks_count; c++)
-    {
-      net = &solver->network_entries[c];
-      net->bw_in_assigned = ril_network_get_assigned(solver, net->type, GNUNET_YES);
-      net->bw_in_utilized = ril_network_get_utilized(solver, net->type, GNUNET_YES);
-      net->bw_out_assigned = ril_network_get_assigned(solver, net->type, GNUNET_NO);
-      net->bw_out_utilized = ril_network_get_utilized(solver, net->type, GNUNET_NO);
-      net->active_agent_count = ril_network_count_active_agents(solver, net);
-      net->social_welfare = ril_network_get_social_welfare(solver, net);
-    }
+  {
+    net = &solver->network_entries[c];
+    net->bw_in_assigned = ril_network_get_assigned (solver, net->type,
+                                                    GNUNET_YES);
+    net->bw_in_utilized = ril_network_get_utilized (solver, net->type,
+                                                    GNUNET_YES);
+    net->bw_out_assigned = ril_network_get_assigned (solver, net->type,
+                                                     GNUNET_NO);
+    net->bw_out_utilized = ril_network_get_utilized (solver, net->type,
+                                                     GNUNET_NO);
+    net->active_agent_count = ril_network_count_active_agents (solver, net);
+    net->social_welfare = ril_network_get_social_welfare (solver, net);
+  }
 }
 
 /**
@@ -1820,7 +1902,7 @@ ril_networks_update_state(struct GAS_RIL_Handle *solver)
  * @param solver the solver handle
  */
 static void
-ril_step_schedule_next(struct GAS_RIL_Handle *solver)
+ril_step_schedule_next (struct GAS_RIL_Handle *solver)
 {
   double used_ratio;
   double factor;
@@ -1828,21 +1910,24 @@ ril_step_schedule_next(struct GAS_RIL_Handle *solver)
   double offset;
   struct GNUNET_TIME_Relative time_next;
 
-  used_ratio = ril_get_used_resource_ratio(solver);
+  used_ratio = ril_get_used_resource_ratio (solver);
 
-  GNUNET_assert(
+  GNUNET_assert (
     solver->parameters.step_time_min.rel_value_us
     <= solver->parameters.step_time_max.rel_value_us);
 
-  factor = (double)GNUNET_TIME_relative_subtract(solver->parameters.step_time_max,
-                                                 solver->parameters.step_time_min).rel_value_us;
-  offset = (double)solver->parameters.step_time_min.rel_value_us;
-  y = factor * pow(used_ratio, RIL_INTERVAL_EXPONENT) + offset;
+  factor = (double) GNUNET_TIME_relative_subtract (
+    solver->parameters.step_time_max,
+    solver->parameters.
+    step_time_min).rel_value_us;
+  offset = (double) solver->parameters.step_time_min.rel_value_us;
+  y = factor * pow (used_ratio, RIL_INTERVAL_EXPONENT) + offset;
 
-  GNUNET_assert(y <= (double)solver->parameters.step_time_max.rel_value_us);
-  GNUNET_assert(y >= (double)solver->parameters.step_time_min.rel_value_us);
+  GNUNET_assert (y <= (double) solver->parameters.step_time_max.rel_value_us);
+  GNUNET_assert (y >= (double) solver->parameters.step_time_min.rel_value_us);
 
-  time_next = GNUNET_TIME_relative_saturating_multiply(GNUNET_TIME_UNIT_MICROSECONDS, (unsigned long long)y);
+  time_next = GNUNET_TIME_relative_saturating_multiply (
+    GNUNET_TIME_UNIT_MICROSECONDS, (unsigned long long) y);
 
 //  LOG (GNUNET_ERROR_TYPE_INFO, "ratio: %f, factor: %f, offset: %f, y: %f\n",
 //      used_ratio,
@@ -1851,15 +1936,17 @@ ril_step_schedule_next(struct GAS_RIL_Handle *solver)
 //      y);
 
   if (solver->simulate)
-    {
-      time_next = GNUNET_TIME_UNIT_ZERO;
-    }
+  {
+    time_next = GNUNET_TIME_UNIT_ZERO;
+  }
 
   if ((NULL == solver->step_next_task_id) && (GNUNET_NO == solver->done))
-    {
-      solver->step_next_task_id = GNUNET_SCHEDULER_add_delayed(time_next, &ril_step_scheduler_task,
-                                                               solver);
-    }
+  {
+    solver->step_next_task_id = GNUNET_SCHEDULER_add_delayed (time_next,
+                                                              &
+                                                              ril_step_scheduler_task,
+                                                              solver);
+  }
 }
 
 /**
@@ -1868,62 +1955,62 @@ ril_step_schedule_next(struct GAS_RIL_Handle *solver)
  * @param solver
  */
 static void
-ril_step(struct GAS_RIL_Handle *solver)
+ril_step (struct GAS_RIL_Handle *solver)
 {
   struct RIL_Peer_Agent *cur;
 
   if (GNUNET_YES == solver->bulk_lock)
-    {
-      solver->bulk_changes++;
-      return;
-    }
+  {
+    solver->bulk_changes++;
+    return;
+  }
 
-  ril_inform(solver, GAS_OP_SOLVE_START, GAS_STAT_SUCCESS);
+  ril_inform (solver, GAS_OP_SOLVE_START, GAS_STAT_SUCCESS);
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "    RIL step number %d\n", solver->step_count);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "    RIL step number %d\n", solver->step_count);
 
   if (0 == solver->step_count)
-    {
-      solver->step_time_last = GNUNET_TIME_absolute_get();
-    }
+  {
+    solver->step_time_last = GNUNET_TIME_absolute_get ();
+  }
 
-  ril_calculate_discount(solver);
-  ril_networks_update_state(solver);
+  ril_calculate_discount (solver);
+  ril_networks_update_state (solver);
 
-  //trigger one step per active, unblocked agent
+  // trigger one step per active, unblocked agent
   for (cur = solver->agents_head; NULL != cur; cur = cur->next)
+  {
+    if (cur->is_active)
     {
-      if (cur->is_active)
-        {
-          if (NULL == cur->address_inuse)
-            {
-              ril_try_unblock_agent(solver, cur, GNUNET_NO);
-            }
-          if (cur->address_inuse)
-            {
-              agent_step(cur);
-            }
-        }
+      if (NULL == cur->address_inuse)
+      {
+        ril_try_unblock_agent (solver, cur, GNUNET_NO);
+      }
+      if (cur->address_inuse)
+      {
+        agent_step (cur);
+      }
     }
+  }
 
-  ril_networks_update_state(solver);
+  ril_networks_update_state (solver);
 
   solver->step_count++;
-  ril_step_schedule_next(solver);
+  ril_step_schedule_next (solver);
 
-  ril_inform(solver, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS);
+  ril_inform (solver, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS);
 
-  ril_inform(solver, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START, GAS_STAT_SUCCESS);
+  ril_inform (solver, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START, GAS_STAT_SUCCESS);
   for (cur = solver->agents_head; NULL != cur; cur = cur->next)
+  {
+    if (cur->suggestion_issue)
     {
-      if (cur->suggestion_issue)
-        {
-          solver->env->bandwidth_changed_cb(solver->env->cls,
-                                            cur->suggestion_address);
-          cur->suggestion_issue = GNUNET_NO;
-        }
+      solver->env->bandwidth_changed_cb (solver->env->cls,
+                                         cur->suggestion_address);
+      cur->suggestion_issue = GNUNET_NO;
     }
-  ril_inform(solver, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP, GAS_STAT_SUCCESS);
+  }
+  ril_inform (solver, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP, GAS_STAT_SUCCESS);
 }
 
 /**
@@ -1932,18 +2019,23 @@ ril_step(struct GAS_RIL_Handle *solver)
  * @param agent The respective agent
  */
 static void
-agent_w_init(struct RIL_Peer_Agent *agent)
+agent_w_init (struct RIL_Peer_Agent *agent)
 {
   int i;
   int k;
 
   for (i = 0; i < agent->n; i++)
+  {
+    for (k = 0; k < agent->m; k++)
     {
-      for (k = 0; k < agent->m; k++)
-        {
-          agent->W[i][k] = agent->envi->parameters.alpha * (1.0 - 2.0 * ((double)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX) / (double)UINT32_MAX));
-        }
+      agent->W[i][k] = agent->envi->parameters.alpha * (1.0 - 2.0
+                                                        * ((double)
+                                                           GNUNET_CRYPTO_random_u32 (
+                                                             GNUNET_CRYPTO_QUALITY_WEAK,
+                                                             UINT32_MAX)
+                                                           / (double) UINT32_MAX));
     }
+  }
 }
 
 /**
@@ -1954,11 +2046,11 @@ agent_w_init(struct RIL_Peer_Agent *agent)
  * @return handle to the new agent
  */
 static struct RIL_Peer_Agent *
-agent_init(void *s, const struct GNUNET_PeerIdentity *peer)
+agent_init (void *s, const struct GNUNET_PeerIdentity *peer)
 {
   int i;
-  struct GAS_RIL_Handle * solver = s;
-  struct RIL_Peer_Agent * agent = GNUNET_new(struct RIL_Peer_Agent);
+  struct GAS_RIL_Handle *solver = s;
+  struct RIL_Peer_Agent *agent = GNUNET_new (struct RIL_Peer_Agent);
 
   agent->envi = solver;
   agent->peer = *peer;
@@ -1969,17 +2061,17 @@ agent_init(void *s, const struct GNUNET_PeerIdentity *peer)
   agent->suggestion_issue = GNUNET_NO;
   agent->n = RIL_ACTION_TYPE_NUM;
   agent->m = 0;
-  agent->W = (double **)GNUNET_malloc(sizeof(double *) * agent->n);
-  agent->E = (double **)GNUNET_malloc(sizeof(double *) * agent->n);
+  agent->W = (double **) GNUNET_malloc (sizeof(double *) * agent->n);
+  agent->E = (double **) GNUNET_malloc (sizeof(double *) * agent->n);
   for (i = 0; i < agent->n; i++)
-    {
-      agent->W[i] = (double *)GNUNET_malloc(sizeof(double) * agent->m);
-      agent->E[i] = (double *)GNUNET_malloc(sizeof(double) * agent->m);
-    }
-  agent_w_init(agent);
+  {
+    agent->W[i] = (double *) GNUNET_malloc (sizeof(double) * agent->m);
+    agent->E[i] = (double *) GNUNET_malloc (sizeof(double) * agent->m);
+  }
+  agent_w_init (agent);
   agent->eligibility_reset = GNUNET_NO;
   agent->a_old = RIL_ACTION_INVALID;
-  agent->s_old = GNUNET_malloc(sizeof(double) * agent->m);
+  agent->s_old = GNUNET_malloc (sizeof(double) * agent->m);
   agent->address_inuse = NULL;
   agent->objective_old = 0;
   agent->nop_bonus = 0;
@@ -1994,19 +2086,19 @@ agent_init(void *s, const struct GNUNET_PeerIdentity *peer)
  * @param agent the agent to retire
  */
 static void
-agent_die(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
+agent_die (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
 {
   int i;
 
   for (i = 0; i < agent->n; i++)
-    {
-      GNUNET_free_non_null(agent->W[i]);
-      GNUNET_free_non_null(agent->E[i]);
-    }
-  GNUNET_free_non_null(agent->W);
-  GNUNET_free_non_null(agent->E);
-  GNUNET_free_non_null(agent->s_old);
-  GNUNET_free(agent);
+  {
+    GNUNET_free_non_null (agent->W[i]);
+    GNUNET_free_non_null (agent->E[i]);
+  }
+  GNUNET_free_non_null (agent->W);
+  GNUNET_free_non_null (agent->E);
+  GNUNET_free_non_null (agent->s_old);
+  GNUNET_free (agent);
 }
 
 /**
@@ -2018,24 +2110,26 @@ agent_die(struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
  * @return the agent
  */
 static struct RIL_Peer_Agent *
-ril_get_agent(struct GAS_RIL_Handle *solver, const struct GNUNET_PeerIdentity *peer, int create)
+ril_get_agent (struct GAS_RIL_Handle *solver, const struct
+               GNUNET_PeerIdentity *peer, int create)
 {
   struct RIL_Peer_Agent *cur;
 
   for (cur = solver->agents_head; NULL != cur; cur = cur->next)
+  {
+    if (0 == GNUNET_memcmp (peer, &cur->peer))
     {
-      if (0 == GNUNET_memcmp(peer, &cur->peer))
-        {
-          return cur;
-        }
+      return cur;
     }
+  }
 
   if (create)
-    {
-      cur = agent_init(solver, peer);
-      GNUNET_CONTAINER_DLL_insert_tail(solver->agents_head, solver->agents_tail, cur);
-      return cur;
-    }
+  {
+    cur = agent_init (solver, peer);
+    GNUNET_CONTAINER_DLL_insert_tail (solver->agents_head, solver->agents_tail,
+                                      cur);
+    return cur;
+  }
   return NULL;
 }
 
@@ -2048,11 +2142,12 @@ ril_get_agent(struct GAS_RIL_Handle *solver, const struct GNUNET_PeerIdentity *p
  * @return whether or not the network is considered active
  */
 static int
-ril_network_is_active(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType network)
+ril_network_is_active (struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType
+                       network)
 {
   struct RIL_Scope *net;
 
-  net = ril_get_network(solver, network);
+  net = ril_get_network (solver, network);
   return net->bw_out_available >= RIL_MIN_BW;
 }
 
@@ -2068,21 +2163,21 @@ ril_network_is_active(struct GAS_RIL_Handle *solver, enum GNUNET_NetworkType net
  * @param old_length the length of the old vector
  */
 static void
-ril_cut_from_vector(void **old,
-                    size_t element_size,
-                    unsigned int hole_start,
-                    unsigned int hole_length,
-                    unsigned int old_length)
+ril_cut_from_vector (void **old,
+                     size_t element_size,
+                     unsigned int hole_start,
+                     unsigned int hole_length,
+                     unsigned int old_length)
 {
   char *tmpptr;
-  char *oldptr = (char *)*old;
+  char *oldptr = (char *) *old;
   size_t size;
   unsigned int bytes_before;
   unsigned int bytes_hole;
   unsigned int bytes_after;
 
-  GNUNET_assert(old_length >= hole_length);
-  GNUNET_assert(old_length >= (hole_start + hole_length));
+  GNUNET_assert (old_length >= hole_length);
+  GNUNET_assert (old_length >= (hole_start + hole_length));
 
   size = element_size * (old_length - hole_length);
 
@@ -2091,20 +2186,21 @@ ril_cut_from_vector(void **old,
   bytes_after = element_size * (old_length - hole_start - hole_length);
 
   if (0 == size)
-    {
-      tmpptr = NULL;
-    }
+  {
+    tmpptr = NULL;
+  }
   else
-    {
-      tmpptr = GNUNET_malloc(size);
-      GNUNET_memcpy(tmpptr, oldptr, bytes_before);
-      GNUNET_memcpy(tmpptr + bytes_before, oldptr + (bytes_before + bytes_hole), bytes_after);
-    }
+  {
+    tmpptr = GNUNET_malloc (size);
+    GNUNET_memcpy (tmpptr, oldptr, bytes_before);
+    GNUNET_memcpy (tmpptr + bytes_before, oldptr + (bytes_before + bytes_hole),
+                   bytes_after);
+  }
   if (NULL != *old)
-    {
-      GNUNET_free(*old);
-    }
-  *old = (void *)tmpptr;
+  {
+    GNUNET_free (*old);
+  }
+  *old = (void *) tmpptr;
 }
 
 /*
@@ -2121,20 +2217,20 @@ ril_cut_from_vector(void **old,
  * @param pref_rel the normalized preference value for this kind over all clients
  */
 static void
-GAS_ril_address_change_preference(void *solver,
-                                  const struct GNUNET_PeerIdentity *peer,
-                                  enum GNUNET_ATS_PreferenceKind kind,
-                                  double pref_rel)
+GAS_ril_address_change_preference (void *solver,
+                                   const struct GNUNET_PeerIdentity *peer,
+                                   enum GNUNET_ATS_PreferenceKind kind,
+                                   double pref_rel)
 {
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_address_change_preference() Preference '%s' for peer '%s' changed to %.2f \n",
-      GNUNET_ATS_print_preference_type(kind), GNUNET_i2s(peer), pref_rel);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_address_change_preference() Preference '%s' for peer '%s' changed to %.2f \n",
+       GNUNET_ATS_print_preference_type (kind), GNUNET_i2s (peer), pref_rel);
 
   struct GAS_RIL_Handle *s = solver;
 
   s->parameters.temperature = s->parameters.temperature_init;
   s->parameters.epsilon = s->parameters.epsilon_init;
-  ril_step(s);
+  ril_step (s);
 }
 
 
@@ -2148,9 +2244,9 @@ GAS_ril_address_change_preference(void *solver,
  * @param network network type of this address
  */
 static void
-GAS_ril_address_add(void *solver,
-                    struct ATS_Address *address,
-                    uint32_t network)
+GAS_ril_address_add (void *solver,
+                     struct ATS_Address *address,
+                     uint32_t network)
 {
   struct GAS_RIL_Handle *s = solver;
   struct RIL_Peer_Agent *agent;
@@ -2163,68 +2259,71 @@ GAS_ril_address_add(void *solver,
   int i;
   unsigned int zero;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_address_add()\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_address_add()\n");
 
-  net = ril_get_network(s, network);
+  net = ril_get_network (s, network);
   address->solver_information = net;
 
-  if (!ril_network_is_active(s, network))
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "API_address_add() Did not add %s address %s for peer '%s', network does not have enough bandwidth\n",
-          address->plugin, address->addr, GNUNET_i2s(&address->peer));
-      return;
-    }
+  if (! ril_network_is_active (s, network))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "API_address_add() Did not add %s address %s for peer '%s', network does not have enough bandwidth\n",
+         address->plugin, address->addr, GNUNET_i2s (&address->peer));
+    return;
+  }
 
   s->parameters.temperature = s->parameters.temperature_init;
   s->parameters.epsilon = s->parameters.epsilon_init;
 
-  agent = ril_get_agent(s, &address->peer, GNUNET_YES);
+  agent = ril_get_agent (s, &address->peer, GNUNET_YES);
 
-  //add address
-  address_wrapped = GNUNET_new(struct RIL_Address_Wrapped);
+  // add address
+  address_wrapped = GNUNET_new (struct RIL_Address_Wrapped);
   address_wrapped->address_naked = address;
-  GNUNET_CONTAINER_DLL_insert_tail(agent->addresses_head, agent->addresses_tail, address_wrapped);
+  GNUNET_CONTAINER_DLL_insert_tail (agent->addresses_head,
+                                    agent->addresses_tail, address_wrapped);
 
-  //increase size of W
-  m_new = agent->m + ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1));
+  // increase size of W
+  m_new = agent->m + ((s->parameters.rbf_divisor + 1)
+                      * (s->parameters.rbf_divisor + 1));
   m_old = agent->m;
   n_new = agent->n + 1;
   n_old = agent->n;
 
-  GNUNET_array_grow(agent->W, agent->n, n_new);
+  GNUNET_array_grow (agent->W, agent->n, n_new);
   agent->n = n_old;
-  GNUNET_array_grow(agent->E, agent->n, n_new);
+  GNUNET_array_grow (agent->E, agent->n, n_new);
   for (i = 0; i < n_new; i++)
+  {
+    if (i < n_old)
     {
-      if (i < n_old)
-        {
-          agent->m = m_old;
-          GNUNET_array_grow(agent->W[i], agent->m, m_new);
-          agent->m = m_old;
-          GNUNET_array_grow(agent->E[i], agent->m, m_new);
-        }
-      else
-        {
-          zero = 0;
-          GNUNET_array_grow(agent->W[i], zero, m_new);
-          zero = 0;
-          GNUNET_array_grow(agent->E[i], zero, m_new);
-        }
+      agent->m = m_old;
+      GNUNET_array_grow (agent->W[i], agent->m, m_new);
+      agent->m = m_old;
+      GNUNET_array_grow (agent->E[i], agent->m, m_new);
+    }
+    else
+    {
+      zero = 0;
+      GNUNET_array_grow (agent->W[i], zero, m_new);
+      zero = 0;
+      GNUNET_array_grow (agent->E[i], zero, m_new);
     }
+  }
 
-  //increase size of old state vector
+  // increase size of old state vector
   agent->m = m_old;
-  GNUNET_array_grow(agent->s_old, agent->m, m_new);
+  GNUNET_array_grow (agent->s_old, agent->m, m_new);
 
-  ril_try_unblock_agent(s, agent, GNUNET_NO);
+  ril_try_unblock_agent (s, agent, GNUNET_NO);
 
-  ril_step(s);
+  ril_step (s);
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "API_address_add() Added %s %s address %s for peer '%s'\n",
-      address->active ? "active" : "inactive", address->plugin, address->addr,
-      GNUNET_i2s(&address->peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_address_add() Added %s %s address %s for peer '%s'\n",
+       address->active ? "active" : "inactive", address->plugin, address->addr,
+       GNUNET_i2s (&address->peer));
 }
 
 /**
@@ -2236,8 +2335,8 @@ GAS_ril_address_add(void *solver,
  * @param address the address to remove
  */
 static void
-GAS_ril_address_delete(void *solver,
-                       struct ATS_Address *address)
+GAS_ril_address_delete (void *solver,
+                        struct ATS_Address *address)
 {
   struct GAS_RIL_Handle *s = solver;
   struct RIL_Peer_Agent *agent;
@@ -2248,103 +2347,112 @@ GAS_ril_address_delete(void *solver,
   int i;
   struct RIL_Scope *net;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_address_delete() Delete %s %s address %s for peer '%s'\n",
-      address->active ? "active" : "inactive",
-      address->plugin,
-      address->addr,
-      GNUNET_i2s(&address->peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_address_delete() Delete %s %s address %s for peer '%s'\n",
+       address->active ? "active" : "inactive",
+       address->plugin,
+       address->addr,
+       GNUNET_i2s (&address->peer));
 
-  agent = ril_get_agent(s, &address->peer, GNUNET_NO);
+  agent = ril_get_agent (s, &address->peer, GNUNET_NO);
   if (NULL == agent)
-    {
-      net = address->solver_information;
-      GNUNET_assert(!ril_network_is_active(s, net->type));
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "No agent allocated for peer yet, since address was in inactive network\n");
-      return;
-    }
+  {
+    net = address->solver_information;
+    GNUNET_assert (! ril_network_is_active (s, net->type));
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "No agent allocated for peer yet, since address was in inactive network\n");
+    return;
+  }
 
   s->parameters.temperature = s->parameters.temperature_init;
   s->parameters.epsilon = s->parameters.epsilon_init;
 
-  address_index = agent_address_get_index(agent, address);
-  address_wrapped = agent_address_get_wrapped(agent, address);
+  address_index = agent_address_get_index (agent, address);
+  address_wrapped = agent_address_get_wrapped (agent, address);
 
   if (NULL == address_wrapped)
-    {
-      net = address->solver_information;
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Address not considered by agent, address was in inactive network\n");
-      return;
-    }
-  GNUNET_CONTAINER_DLL_remove(agent->addresses_head,
-                              agent->addresses_tail,
-                              address_wrapped);
-  GNUNET_free(address_wrapped);
-
-  //decrease W
-  m_new = agent->m - ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1));
+  {
+    net = address->solver_information;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Address not considered by agent, address was in inactive network\n");
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (agent->addresses_head,
+                               agent->addresses_tail,
+                               address_wrapped);
+  GNUNET_free (address_wrapped);
+
+  // decrease W
+  m_new = agent->m - ((s->parameters.rbf_divisor + 1)
+                      * (s->parameters.rbf_divisor + 1));
   n_new = agent->n - 1;
 
   for (i = 0; i < agent->n; i++)
-    {
-      ril_cut_from_vector((void **)&agent->W[i], sizeof(double),
-                          address_index * ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1)),
-                          ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1)), agent->m);
-      ril_cut_from_vector((void **)&agent->E[i], sizeof(double),
-                          address_index * ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1)),
-                          ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1)), agent->m);
-    }
-  GNUNET_free_non_null(agent->W[RIL_ACTION_TYPE_NUM + address_index]);
-  GNUNET_free_non_null(agent->E[RIL_ACTION_TYPE_NUM + address_index]);
-  ril_cut_from_vector((void **)&agent->W, sizeof(double *), RIL_ACTION_TYPE_NUM + address_index,
-                      1, agent->n);
-  ril_cut_from_vector((void **)&agent->E, sizeof(double *), RIL_ACTION_TYPE_NUM + address_index,
-                      1, agent->n);
-  //correct last action
+  {
+    ril_cut_from_vector ((void **) &agent->W[i], sizeof(double),
+                         address_index * ((s->parameters.rbf_divisor + 1)
+                                          * (s->parameters.rbf_divisor + 1)),
+                         ((s->parameters.rbf_divisor + 1)
+                          * (s->parameters.rbf_divisor + 1)), agent->m);
+    ril_cut_from_vector ((void **) &agent->E[i], sizeof(double),
+                         address_index * ((s->parameters.rbf_divisor + 1)
+                                          * (s->parameters.rbf_divisor + 1)),
+                         ((s->parameters.rbf_divisor + 1)
+                          * (s->parameters.rbf_divisor + 1)), agent->m);
+  }
+  GNUNET_free_non_null (agent->W[RIL_ACTION_TYPE_NUM + address_index]);
+  GNUNET_free_non_null (agent->E[RIL_ACTION_TYPE_NUM + address_index]);
+  ril_cut_from_vector ((void **) &agent->W, sizeof(double *),
+                       RIL_ACTION_TYPE_NUM + address_index,
+                       1, agent->n);
+  ril_cut_from_vector ((void **) &agent->E, sizeof(double *),
+                       RIL_ACTION_TYPE_NUM + address_index,
+                       1, agent->n);
+  // correct last action
   if (agent->a_old > (RIL_ACTION_TYPE_NUM + address_index))
-    {
-      agent->a_old -= 1;
-    }
+  {
+    agent->a_old -= 1;
+  }
   else if (agent->a_old == (RIL_ACTION_TYPE_NUM + address_index))
-    {
-      agent->a_old = RIL_ACTION_INVALID;
-    }
-  //decrease old state vector
-  ril_cut_from_vector((void **)&agent->s_old, sizeof(double),
-                      address_index * ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1)),
-                      ((s->parameters.rbf_divisor + 1) * (s->parameters.rbf_divisor + 1)), agent->m);
+  {
+    agent->a_old = RIL_ACTION_INVALID;
+  }
+  // decrease old state vector
+  ril_cut_from_vector ((void **) &agent->s_old, sizeof(double),
+                       address_index * ((s->parameters.rbf_divisor + 1)
+                                        * (s->parameters.rbf_divisor + 1)),
+                       ((s->parameters.rbf_divisor + 1)
+                        * (s->parameters.rbf_divisor + 1)), agent->m);
   agent->m = m_new;
   agent->n = n_new;
 
   if (agent->address_inuse == address)
-    {
-      if (NULL != agent->addresses_head) //if peer has an address left, use it
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Active address died, suggesting alternative!\n");
-          envi_set_active_suggestion(s,
-                                     agent,
-                                     agent->addresses_head->address_naked,
-                                     agent->bw_in,
-                                     agent->bw_out,
-                                     GNUNET_YES);
-        }
-      else
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Active address died, suggesting disconnect!\n");
-          envi_set_active_suggestion(s, agent, NULL, 0, 0, GNUNET_NO);
-        }
-    }
-  ril_step(solver);
+  {
+    if (NULL != agent->addresses_head)   // if peer has an address left, use it
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Active address died, suggesting alternative!\n");
+      envi_set_active_suggestion (s,
+                                  agent,
+                                  agent->addresses_head->address_naked,
+                                  agent->bw_in,
+                                  agent->bw_out,
+                                  GNUNET_YES);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Active address died, suggesting disconnect!\n");
+      envi_set_active_suggestion (s, agent, NULL, 0, 0, GNUNET_NO);
+    }
+  }
+  ril_step (solver);
   if (agent->suggestion_address == address)
-    {
-      agent->suggestion_issue = GNUNET_NO;
-      agent->suggestion_address = NULL;
-    }
-  GNUNET_assert(agent->address_inuse != address);
+  {
+    agent->suggestion_issue = GNUNET_NO;
+    agent->suggestion_address = NULL;
+  }
+  GNUNET_assert (agent->address_inuse != address);
 }
 
 
@@ -2355,17 +2463,17 @@ GAS_ril_address_delete(void *solver,
  * @param address the address
  */
 static void
-GAS_ril_address_property_changed(void *solver,
-                                 struct ATS_Address *address)
+GAS_ril_address_property_changed (void *solver,
+                                  struct ATS_Address *address)
 {
   struct GAS_RIL_Handle *s = solver;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Properties for peer '%s' address changed\n",
-      GNUNET_i2s(&address->peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Properties for peer '%s' address changed\n",
+       GNUNET_i2s (&address->peer));
   s->parameters.temperature = s->parameters.temperature_init;
   s->parameters.epsilon = s->parameters.epsilon_init;
-  ril_step(s);
+  ril_step (s);
 }
 
 
@@ -2380,20 +2488,20 @@ GAS_ril_address_property_changed(void *solver,
  * @param score the score
  */
 static void
-GAS_ril_address_preference_feedback(void *solver,
-                                    struct GNUNET_SERVICE_Client *application,
-                                    const struct GNUNET_PeerIdentity *peer,
-                                    const struct GNUNET_TIME_Relative scope,
-                                    enum GNUNET_ATS_PreferenceKind kind,
-                                    double score)
-{
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_address_preference_feedback() Peer '%s' got a feedback of %+.3f from application %s for "
-      "preference %s for %d seconds\n",
-      GNUNET_i2s(peer),
-      "UNKNOWN",
-      GNUNET_ATS_print_preference_type(kind),
-      scope.rel_value_us / 1000000);
+GAS_ril_address_preference_feedback (void *solver,
+                                     struct GNUNET_SERVICE_Client *application,
+                                     const struct GNUNET_PeerIdentity *peer,
+                                     const struct GNUNET_TIME_Relative scope,
+                                     enum GNUNET_ATS_PreferenceKind kind,
+                                     double score)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_address_preference_feedback() Peer '%s' got a feedback of %+.3f from application %s for "
+       "preference %s for %d seconds\n",
+       GNUNET_i2s (peer),
+       "UNKNOWN",
+       GNUNET_ATS_print_preference_type (kind),
+       scope.rel_value_us / 1000000);
 }
 
 
@@ -2403,12 +2511,12 @@ GAS_ril_address_preference_feedback(void *solver,
  * @param solver the solver
  */
 static void
-GAS_ril_bulk_start(void *solver)
+GAS_ril_bulk_start (void *solver)
 {
   struct GAS_RIL_Handle *s = solver;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_bulk_start() lock: %d\n", s->bulk_lock + 1);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_bulk_start() lock: %d\n", s->bulk_lock + 1);
 
   s->bulk_lock++;
 }
@@ -2420,26 +2528,26 @@ GAS_ril_bulk_start(void *solver)
  * @param solver the solver handle
  */
 static void
-GAS_ril_bulk_stop(void *solver)
+GAS_ril_bulk_stop (void *solver)
 {
   struct GAS_RIL_Handle *s = solver;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_bulk_stop() lock: %d\n",
-      s->bulk_lock - 1);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_bulk_stop() lock: %d\n",
+       s->bulk_lock - 1);
 
   if (s->bulk_lock < 1)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   s->bulk_lock--;
 
   if (0 < s->bulk_changes)
-    {
-      ril_step(solver);
-      s->bulk_changes = 0;
-    }
+  {
+    ril_step (solver);
+    s->bulk_changes = 0;
+  }
 }
 
 
@@ -2454,38 +2562,40 @@ GAS_ril_bulk_stop(void *solver)
  * @param peer the identity of the peer
  */
 static void
-GAS_ril_get_preferred_address(void *solver,
-                              const struct GNUNET_PeerIdentity *peer)
+GAS_ril_get_preferred_address (void *solver,
+                               const struct GNUNET_PeerIdentity *peer)
 {
   struct GAS_RIL_Handle *s = solver;
   struct RIL_Peer_Agent *agent;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "API_get_preferred_address()\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "API_get_preferred_address()\n");
 
-  agent = ril_get_agent(s, peer, GNUNET_YES);
+  agent = ril_get_agent (s, peer, GNUNET_YES);
 
   agent->is_active = GNUNET_YES;
-  envi_set_active_suggestion(solver, agent, agent->address_inuse, agent->bw_in, agent->bw_out, GNUNET_YES);
+  envi_set_active_suggestion (solver, agent, agent->address_inuse, agent->bw_in,
+                              agent->bw_out, GNUNET_YES);
 
-  ril_try_unblock_agent(solver, agent, GNUNET_YES);
+  ril_try_unblock_agent (solver, agent, GNUNET_YES);
 
   if (agent->address_inuse)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "API_get_preferred_address() Activated agent for peer '%s' with %s address %s\n",
-          GNUNET_i2s(peer), agent->address_inuse->plugin, agent->address_inuse->addr);
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "API_get_preferred_address() Activated agent for peer '%s' with %s address %s\n",
+         GNUNET_i2s (peer), agent->address_inuse->plugin,
+         agent->address_inuse->addr);
+  }
   else
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "API_get_preferred_address() Activated agent for peer '%s', but no address available\n",
-          GNUNET_i2s(peer));
-      s->parameters.temperature = s->parameters.temperature_init;
-      s->parameters.epsilon = s->parameters.epsilon_init;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "API_get_preferred_address() Activated agent for peer '%s', but no address available\n",
+         GNUNET_i2s (peer));
+    s->parameters.temperature = s->parameters.temperature_init;
+    s->parameters.epsilon = s->parameters.epsilon_init;
+  }
   if (NULL != agent->address_inuse)
-    s->env->bandwidth_changed_cb(s->env->cls,
-                                 agent->address_inuse);
+    s->env->bandwidth_changed_cb (s->env->cls,
+                                  agent->address_inuse);
 }
 
 
@@ -2499,41 +2609,42 @@ GAS_ril_get_preferred_address(void *solver,
  * @param peer the peer
  */
 static void
-GAS_ril_stop_get_preferred_address(void *solver,
-                                   const struct GNUNET_PeerIdentity *peer)
+GAS_ril_stop_get_preferred_address (void *solver,
+                                    const struct GNUNET_PeerIdentity *peer)
 {
   struct GAS_RIL_Handle *s = solver;
   struct RIL_Peer_Agent *agent;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_stop_get_preferred_address()");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_stop_get_preferred_address()");
 
-  agent = ril_get_agent(s, peer, GNUNET_NO);
+  agent = ril_get_agent (s, peer, GNUNET_NO);
 
   if (NULL == agent)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   if (GNUNET_NO == agent->is_active)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
 
   s->parameters.temperature = s->parameters.temperature_init;
   s->parameters.epsilon = s->parameters.epsilon_init;
 
   agent->is_active = GNUNET_NO;
 
-  envi_set_active_suggestion(s, agent, agent->address_inuse, agent->bw_in, agent->bw_out,
-                             GNUNET_YES);
+  envi_set_active_suggestion (s, agent, agent->address_inuse, agent->bw_in,
+                              agent->bw_out,
+                              GNUNET_YES);
 
-  ril_step(s);
+  ril_step (s);
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_stop_get_preferred_address() Paused agent for peer '%s'\n",
-      GNUNET_i2s(peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_stop_get_preferred_address() Paused agent for peer '%s'\n",
+       GNUNET_i2s (peer));
 }
 
 
@@ -2543,233 +2654,258 @@ GAS_ril_stop_get_preferred_address(void *solver,
  * @param cls pointer to the 'struct GNUNET_ATS_PluginEnvironment'
  */
 void *
-libgnunet_plugin_ats_ril_init(void *cls)
+libgnunet_plugin_ats_ril_init (void *cls)
 {
   static struct GNUNET_ATS_SolverFunctions sf;
   struct GNUNET_ATS_PluginEnvironment *env = cls;
-  struct GAS_RIL_Handle *solver = GNUNET_new(struct GAS_RIL_Handle);
-  struct RIL_Scope * cur;
+  struct GAS_RIL_Handle *solver = GNUNET_new (struct GAS_RIL_Handle);
+  struct RIL_Scope *cur;
   int c;
   char *string;
   float f_tmp;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_init() Initializing RIL solver\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "API_init() Initializing RIL solver\n");
 
-  GNUNET_assert(NULL != env);
-  GNUNET_assert(NULL != env->cfg);
-  GNUNET_assert(NULL != env->stats);
-  GNUNET_assert(NULL != env->bandwidth_changed_cb);
-  GNUNET_assert(NULL != env->get_preferences);
+  GNUNET_assert (NULL != env);
+  GNUNET_assert (NULL != env->cfg);
+  GNUNET_assert (NULL != env->stats);
+  GNUNET_assert (NULL != env->bandwidth_changed_cb);
+  GNUNET_assert (NULL != env->get_preferences);
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(env->cfg, "ats", "RIL_RBF_DIVISOR", &solver->parameters.rbf_divisor))
-    {
-      solver->parameters.rbf_divisor = RIL_DEFAULT_RBF_DIVISOR;
-    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (env->cfg, "ats",
+                                                          "RIL_RBF_DIVISOR",
+                                                          &solver->parameters.
+                                                          rbf_divisor))
+  {
+    solver->parameters.rbf_divisor = RIL_DEFAULT_RBF_DIVISOR;
+  }
 
   if (GNUNET_OK
-      != GNUNET_CONFIGURATION_get_value_time(env->cfg, "ats", "RIL_STEP_TIME_MIN",
-                                             &solver->parameters.step_time_min))
-    {
-      solver->parameters.step_time_min = RIL_DEFAULT_STEP_TIME_MIN;
-    }
+      != GNUNET_CONFIGURATION_get_value_time (env->cfg, "ats",
+                                              "RIL_STEP_TIME_MIN",
+                                              &solver->parameters.step_time_min))
+  {
+    solver->parameters.step_time_min = RIL_DEFAULT_STEP_TIME_MIN;
+  }
 
   if (GNUNET_OK
-      != GNUNET_CONFIGURATION_get_value_time(env->cfg, "ats", "RIL_STEP_TIME_MAX",
-                                             &solver->parameters.step_time_max))
-    {
-      solver->parameters.step_time_max = RIL_DEFAULT_STEP_TIME_MAX;
-    }
+      != GNUNET_CONFIGURATION_get_value_time (env->cfg, "ats",
+                                              "RIL_STEP_TIME_MAX",
+                                              &solver->parameters.step_time_max))
+  {
+    solver->parameters.step_time_max = RIL_DEFAULT_STEP_TIME_MAX;
+  }
 
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(env->cfg, "ats", "RIL_ALGORITHM", &string))
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (env->cfg, "ats",
+                                                          "RIL_ALGORITHM",
+                                                          &string))
+  {
+    GNUNET_STRINGS_utf8_toupper (string, string);
+    if (0 == strcmp (string, "SARSA"))
     {
-      GNUNET_STRINGS_utf8_toupper(string, string);
-      if (0 == strcmp(string, "SARSA"))
-        {
-          solver->parameters.algorithm = RIL_ALGO_SARSA;
-        }
-      if (0 == strcmp(string, "Q-LEARNING"))
-        {
-          solver->parameters.algorithm = RIL_ALGO_Q;
-        }
-
-      GNUNET_free(string);
+      solver->parameters.algorithm = RIL_ALGO_SARSA;
     }
-  else
+    if (0 == strcmp (string, "Q-LEARNING"))
     {
-      solver->parameters.algorithm = RIL_DEFAULT_ALGORITHM;
+      solver->parameters.algorithm = RIL_ALGO_Q;
     }
 
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(env->cfg, "ats", "RIL_SELECT", &string))
-    {
-      solver->parameters.select = !strcmp(string, "EGREEDY") ? RIL_SELECT_EGREEDY : RIL_SELECT_SOFTMAX;
-      GNUNET_free(string);
-    }
+    GNUNET_free (string);
+  }
   else
-    {
-      solver->parameters.select = RIL_DEFAULT_SELECT;
-    }
+  {
+    solver->parameters.algorithm = RIL_DEFAULT_ALGORITHM;
+  }
+
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (env->cfg, "ats",
+                                                          "RIL_SELECT",
+                                                          &string))
+  {
+    solver->parameters.select = ! strcmp (string, "EGREEDY") ?
+                                RIL_SELECT_EGREEDY : RIL_SELECT_SOFTMAX;
+    GNUNET_free (string);
+  }
+  else
+  {
+    solver->parameters.select = RIL_DEFAULT_SELECT;
+  }
 
 
   solver->parameters.beta = RIL_DEFAULT_DISCOUNT_BETA;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_DISCOUNT_BETA", &f_tmp))
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_DISCOUNT_BETA",
+                                                             &f_tmp))
+  {
+    if (f_tmp < 0.0)
     {
-      if (f_tmp < 0.0)
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_DISCOUNT_BETA", f_tmp);
-        }
-      else
-        {
-          solver->parameters.beta = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_DISCOUNT_BETA", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_DISCOUNT_BETA", f_tmp);
+    }
+    else
+    {
+      solver->parameters.beta = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_DISCOUNT_BETA", f_tmp);
     }
+  }
 
   solver->parameters.gamma = RIL_DEFAULT_DISCOUNT_GAMMA;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_DISCOUNT_GAMMA", &f_tmp))
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_DISCOUNT_GAMMA",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0) || (f_tmp > 1.0))
     {
-      if ((f_tmp < 0.0) || (f_tmp > 1.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_DISCOUNT_GAMMA", f_tmp);
-        }
-      else
-        {
-          solver->parameters.gamma = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_DISCOUNT_GAMMA", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_DISCOUNT_GAMMA", f_tmp);
     }
-
-  solver->parameters.alpha = RIL_DEFAULT_GRADIENT_STEP_SIZE;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_GRADIENT_STEP_SIZE", &f_tmp))
+    else
     {
-      if ((f_tmp < 0.0) || (f_tmp > 1.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_GRADIENT_STEP_SIZE", f_tmp);
-        }
-      else
-        {
-          solver->parameters.alpha = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_GRADIENT_STEP_SIZE", f_tmp);
-        }
+      solver->parameters.gamma = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_DISCOUNT_GAMMA", f_tmp);
     }
+  }
 
-  solver->parameters.lambda = RIL_DEFAULT_TRACE_DECAY;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_TRACE_DECAY", &f_tmp))
+  solver->parameters.alpha = RIL_DEFAULT_GRADIENT_STEP_SIZE;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_GRADIENT_STEP_SIZE",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0) || (f_tmp > 1.0))
     {
-      if ((f_tmp < 0.0) || (f_tmp > 1.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_TRACE_DECAY", f_tmp);
-        }
-      else
-        {
-          solver->parameters.lambda = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_TRACE_DECAY", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_GRADIENT_STEP_SIZE", f_tmp);
     }
-
-  solver->parameters.epsilon_init = RIL_DEFAULT_EXPLORE_RATIO;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_EXPLORE_RATIO", &f_tmp))
+    else
     {
-      if ((f_tmp < 0.0) || (f_tmp > 1.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_EXPLORE_RATIO", f_tmp);
-        }
-      else
-        {
-          solver->parameters.epsilon_init = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_EXPLORE_RATIO", f_tmp);
-        }
+      solver->parameters.alpha = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_GRADIENT_STEP_SIZE", f_tmp);
     }
+  }
 
-  solver->parameters.epsilon_decay = RIL_DEFAULT_EXPLORE_DECAY;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_EXPLORE_DECAY", &f_tmp))
+  solver->parameters.lambda = RIL_DEFAULT_TRACE_DECAY;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_TRACE_DECAY",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0) || (f_tmp > 1.0))
     {
-      if ((f_tmp < 0.0) || (f_tmp > 1.0))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_EXPLORE_DECAY", f_tmp);
-        }
-      else
-        {
-          solver->parameters.epsilon_decay = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_EXPLORE_DECAY", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_TRACE_DECAY", f_tmp);
     }
-
-  solver->parameters.temperature_init = RIL_DEFAULT_TEMPERATURE;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_TEMPERATURE", &f_tmp))
+    else
     {
-      if (f_tmp <= 0.0)
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_TEMPERATURE", f_tmp);
-        }
-      else
-        {
-          solver->parameters.temperature_init = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_TEMPERATURE", f_tmp);
-        }
+      solver->parameters.lambda = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_TRACE_DECAY", f_tmp);
     }
+  }
 
-  solver->parameters.temperature_decay = RIL_DEFAULT_TEMPERATURE_DECAY;
-  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float(env->cfg, "ats",
-                                                            "RIL_TEMPERATURE_DECAY", &f_tmp))
+  solver->parameters.epsilon_init = RIL_DEFAULT_EXPLORE_RATIO;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_EXPLORE_RATIO",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0) || (f_tmp > 1.0))
     {
-      if ((f_tmp <= 0.0) || solver->parameters.temperature_decay > 1)
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR, _("Invalid %s configuration %f \n"),
-              "RIL_TEMPERATURE_DECAY", f_tmp);
-        }
-      else
-        {
-          solver->parameters.temperature_decay = f_tmp;
-          LOG(GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
-              "RIL_TEMPERATURE_DECAY", f_tmp);
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_EXPLORE_RATIO", f_tmp);
     }
-
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(env->cfg, "ats", "RIL_SIMULATE", &solver->simulate))
+    else
     {
-      solver->simulate = GNUNET_NO;
+      solver->parameters.epsilon_init = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_EXPLORE_RATIO", f_tmp);
     }
+  }
 
-  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(env->cfg, "ats", "RIL_REPLACE_TRACES"))
+  solver->parameters.epsilon_decay = RIL_DEFAULT_EXPLORE_DECAY;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_EXPLORE_DECAY",
+                                                             &f_tmp))
+  {
+    if ((f_tmp < 0.0) || (f_tmp > 1.0))
     {
-      solver->parameters.eligibility_trace_mode = RIL_E_REPLACE;
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_EXPLORE_DECAY", f_tmp);
     }
-  else
+    else
     {
-      solver->parameters.eligibility_trace_mode = RIL_E_ACCUMULATE;
+      solver->parameters.epsilon_decay = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_EXPLORE_DECAY", f_tmp);
     }
+  }
 
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(env->cfg, "ats", "RIL_SOCIAL_WELFARE", &string))
+  solver->parameters.temperature_init = RIL_DEFAULT_TEMPERATURE;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_TEMPERATURE",
+                                                             &f_tmp))
+  {
+    if (f_tmp <= 0.0)
     {
-      solver->parameters.social_welfare = !strcmp(string, "NASH") ? RIL_WELFARE_NASH : RIL_WELFARE_EGALITARIAN;
-      GNUNET_free(string);
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_TEMPERATURE", f_tmp);
     }
-  else
+    else
     {
-      solver->parameters.social_welfare = RIL_DEFAULT_WELFARE;
+      solver->parameters.temperature_init = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_TEMPERATURE", f_tmp);
     }
+  }
+
+  solver->parameters.temperature_decay = RIL_DEFAULT_TEMPERATURE_DECAY;
+  if (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
+                                                             "RIL_TEMPERATURE_DECAY",
+                                                             &f_tmp))
+  {
+    if ((f_tmp <= 0.0) ||(solver->parameters.temperature_decay > 1) )
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Invalid %s configuration %f \n"),
+           "RIL_TEMPERATURE_DECAY", f_tmp);
+    }
+    else
+    {
+      solver->parameters.temperature_decay = f_tmp;
+      LOG (GNUNET_ERROR_TYPE_INFO, "Using %s of %.3f\n",
+           "RIL_TEMPERATURE_DECAY", f_tmp);
+    }
+  }
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (env->cfg, "ats",
+                                                          "RIL_SIMULATE",
+                                                          &solver->simulate))
+  {
+    solver->simulate = GNUNET_NO;
+  }
+
+  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "ats",
+                                                          "RIL_REPLACE_TRACES"))
+  {
+    solver->parameters.eligibility_trace_mode = RIL_E_REPLACE;
+  }
+  else
+  {
+    solver->parameters.eligibility_trace_mode = RIL_E_ACCUMULATE;
+  }
+
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (env->cfg, "ats",
+                                                          "RIL_SOCIAL_WELFARE",
+                                                          &string))
+  {
+    solver->parameters.social_welfare = ! strcmp (string, "NASH") ?
+                                        RIL_WELFARE_NASH :
+                                        RIL_WELFARE_EGALITARIAN;
+    GNUNET_free (string);
+  }
+  else
+  {
+    solver->parameters.social_welfare = RIL_DEFAULT_WELFARE;
+  }
 
   solver->env = env;
   sf.cls = solver;
@@ -2784,35 +2920,38 @@ libgnunet_plugin_ats_ril_init(void *cls)
   sf.s_bulk_stop = &GAS_ril_bulk_stop;
 
   solver->networks_count = env->network_count;
-  solver->network_entries = GNUNET_malloc(env->network_count * sizeof(struct RIL_Scope));
+  solver->network_entries = GNUNET_malloc (env->network_count * sizeof(struct
+                                                                       RIL_Scope));
   solver->step_count = 0;
   solver->done = GNUNET_NO;
 
   for (c = 0; c < env->network_count; c++)
-    {
-      cur = &solver->network_entries[c];
-      cur->type = c;
-      cur->bw_in_available = env->in_quota[c];
-      cur->bw_out_available = env->out_quota[c];
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "init()  Quotas for %s network:  IN %llu - OUT %llu\n",
-          GNUNET_NT_to_string(cur->type),
-          cur->bw_in_available / 1024,
-          cur->bw_out_available / 1024);
-    }
-
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "init()  Parameters:\n");
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "init()  Algorithm = %s, alpha = %f, beta = %f, lambda = %f\n",
-      solver->parameters.algorithm ? "Q" : "SARSA",
-      solver->parameters.alpha,
-      solver->parameters.beta,
-      solver->parameters.lambda);
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "init()  exploration_ratio = %f, temperature = %f, ActionSelection = %s\n",
-      solver->parameters.epsilon,
-      solver->parameters.temperature,
-      solver->parameters.select ? "EGREEDY" : "SOFTMAX");
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "init()  RBF_DIVISOR = %llu\n",
-      solver->parameters.rbf_divisor);
+  {
+    cur = &solver->network_entries[c];
+    cur->type = c;
+    cur->bw_in_available = env->in_quota[c];
+    cur->bw_out_available = env->out_quota[c];
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "init()  Quotas for %s network:  IN %llu - OUT %llu\n",
+         GNUNET_NT_to_string (cur->type),
+         cur->bw_in_available / 1024,
+         cur->bw_out_available / 1024);
+  }
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "init()  Parameters:\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "init()  Algorithm = %s, alpha = %f, beta = %f, lambda = %f\n",
+       solver->parameters.algorithm ? "Q" : "SARSA",
+       solver->parameters.alpha,
+       solver->parameters.beta,
+       solver->parameters.lambda);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "init()  exploration_ratio = %f, temperature = %f, ActionSelection = %s\n",
+       solver->parameters.epsilon,
+       solver->parameters.temperature,
+       solver->parameters.select ? "EGREEDY" : "SOFTMAX");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "init()  RBF_DIVISOR = %llu\n",
+       solver->parameters.rbf_divisor);
 
   return &sf;
 }
@@ -2824,32 +2963,32 @@ libgnunet_plugin_ats_ril_init(void *cls)
  * @param cls the solver handle
  */
 void *
-libgnunet_plugin_ats_ril_done(void *cls)
+libgnunet_plugin_ats_ril_done (void *cls)
 {
   struct GNUNET_ATS_SolverFunctions *sf = cls;
   struct GAS_RIL_Handle *s = sf->cls;
   struct RIL_Peer_Agent *cur_agent;
   struct RIL_Peer_Agent *next_agent;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "API_done() Shutting down RIL solver\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "API_done() Shutting down RIL solver\n");
 
   s->done = GNUNET_YES;
 
   cur_agent = s->agents_head;
   while (NULL != cur_agent)
-    {
-      next_agent = cur_agent->next;
-      GNUNET_CONTAINER_DLL_remove(s->agents_head, s->agents_tail, cur_agent);
-      agent_die(s, cur_agent);
-      cur_agent = next_agent;
-    }
+  {
+    next_agent = cur_agent->next;
+    GNUNET_CONTAINER_DLL_remove (s->agents_head, s->agents_tail, cur_agent);
+    agent_die (s, cur_agent);
+    cur_agent = next_agent;
+  }
 
   if (NULL != s->step_next_task_id)
-    {
-      GNUNET_SCHEDULER_cancel(s->step_next_task_id);
-    }
-  GNUNET_free(s->network_entries);
-  GNUNET_free(s);
+  {
+    GNUNET_SCHEDULER_cancel (s->step_next_task_id);
+  }
+  GNUNET_free (s->network_entries);
+  GNUNET_free (s);
 
   return NULL;
 }
diff --git a/src/ats/test_ats2_lib.c b/src/ats/test_ats2_lib.c
index 1b9f0e234..f2a8eb1ea 100644
--- a/src/ats/test_ats2_lib.c
+++ b/src/ats/test_ats2_lib.c
@@ -76,13 +76,13 @@ static struct GNUNET_ATS_SessionRecord *sr;
  * @return
  */
 static void
-allocation_cb(void *cls,
-              struct GNUNET_ATS_Session *session,
-              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+allocation_cb (void *cls,
+               struct GNUNET_ATS_Session *session,
+               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "allocation_cb() called\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "allocation_cb() called\n");
 }
 
 
@@ -96,12 +96,12 @@ allocation_cb(void *cls,
  * @param address
  */
 static void
-suggestion_cb(void *cls,
-              const struct GNUNET_PeerIdentity *pid,
-              const char *address)
+suggestion_cb (void *cls,
+               const struct GNUNET_PeerIdentity *pid,
+               const char *address)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "suggestion_cb() called\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "suggestion_cb() called\n");
   ret = 0;
 }
 
@@ -112,16 +112,16 @@ suggestion_cb(void *cls,
  * Initialises the application and transportation side of ATS.
  */
 static void
-init_both(const struct GNUNET_CONFIGURATION_Handle *cfg)
+init_both (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  ah = GNUNET_ATS_application_init(cfg);
-  GNUNET_assert(NULL != ah);
-  th = GNUNET_ATS_transport_init(cfg,
-                                 &allocation_cb,
-                                 NULL,
-                                 &suggestion_cb,
-                                 NULL);
-  GNUNET_assert(NULL != ah);
+  ah = GNUNET_ATS_application_init (cfg);
+  GNUNET_assert (NULL != ah);
+  th = GNUNET_ATS_transport_init (cfg,
+                                  &allocation_cb,
+                                  NULL,
+                                  &suggestion_cb,
+                                  NULL);
+  GNUNET_assert (NULL != ah);
 }
 
 
@@ -129,11 +129,11 @@ init_both(const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @brief Disconnect both 'sides' of ATS
  */
 static void
-finish_both(void)
+finish_both (void)
 {
-  GNUNET_ATS_application_done(ah);
+  GNUNET_ATS_application_done (ah);
   ah = NULL;
-  GNUNET_ATS_transport_done(th);
+  GNUNET_ATS_transport_done (th);
   th = NULL;
 }
 
@@ -142,10 +142,9 @@ finish_both(void)
  * @brief Provide information about the start of an imaginary connection
  */
 static void
-provide_info_start(void)
+provide_info_start (void)
 {
-  struct GNUNET_ATS_Properties prop =
-  {
+  struct GNUNET_ATS_Properties prop = {
     .delay = GNUNET_TIME_UNIT_FOREVER_REL,
     .goodput_out = 1048576,
     .goodput_in = 1048576,
@@ -157,12 +156,12 @@ provide_info_start(void)
     .cc = GNUNET_TRANSPORT_CC_UNKNOWN,
   };
 
-  sr = GNUNET_ATS_session_add(th,
-                              &other_peer,
-                              "test-address",
-                              NULL,
-                              &prop);
-  GNUNET_assert(NULL != sr);
+  sr = GNUNET_ATS_session_add (th,
+                               &other_peer,
+                               "test-address",
+                               NULL,
+                               &prop);
+  GNUNET_assert (NULL != sr);
 }
 
 
@@ -170,9 +169,9 @@ provide_info_start(void)
  * @brief Provide information about the end of an imaginary connection
  */
 static void
-provide_info_end(void)
+provide_info_end (void)
 {
-  GNUNET_ATS_session_del(sr);
+  GNUNET_ATS_session_del (sr);
 }
 
 
@@ -180,24 +179,24 @@ provide_info_end(void)
  * @brief Inform ATS about the need of a connection towards a peer
  */
 static void
-get_suggestion(void)
+get_suggestion (void)
 {
   struct GNUNET_ATS_ApplicationSuggestHandle *ash;
 
-  ash = GNUNET_ATS_application_suggest(ah,
-                                       &other_peer,
-                                       GNUNET_MQ_PREFERENCE_NONE,
-                                       GNUNET_BANDWIDTH_VALUE_MAX);
-  GNUNET_assert(NULL != ash);
+  ash = GNUNET_ATS_application_suggest (ah,
+                                        &other_peer,
+                                        GNUNET_MQ_PREFERENCE_NONE,
+                                        GNUNET_BANDWIDTH_VALUE_MAX);
+  GNUNET_assert (NULL != ash);
 }
 
 
 static void
-on_shutdown(void *cls)
+on_shutdown (void *cls)
 {
-  provide_info_end();
-  finish_both();
-  GNUNET_SCHEDULER_shutdown();
+  provide_info_end ();
+  finish_both ();
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -209,16 +208,16 @@ on_shutdown(void *cls)
  * @param peer handle to the peer
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
-  init_both(cfg);
-  provide_info_start();
-  get_suggestion();
-  (void)GNUNET_SCHEDULER_add_delayed(timeout,
-                                     &on_shutdown,
-                                     NULL);
+  init_both (cfg);
+  provide_info_start ();
+  get_suggestion ();
+  (void) GNUNET_SCHEDULER_add_delayed (timeout,
+                                       &on_shutdown,
+                                       NULL);
 }
 
 
@@ -231,27 +230,27 @@ run(void *cls,
  * @return
  */
 int
-main(int argc,
-     char *argv[])
+main (int argc,
+      char *argv[])
 {
   ret = 1;
-  memset(&other_peer, 0, sizeof(struct GNUNET_PeerIdentity));
-  timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-                                          2);
-  if (0 != GNUNET_TESTING_peer_run("test-ats2-lib",
-                                   "test_ats2_lib.conf",
-                                   &run, NULL))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Running the testing peer failed.\n");
-      return 1;
-    }
+  memset (&other_peer, 0, sizeof(struct GNUNET_PeerIdentity));
+  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                           2);
+  if (0 != GNUNET_TESTING_peer_run ("test-ats2-lib",
+                                    "test_ats2_lib.conf",
+                                    &run, NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Running the testing peer failed.\n");
+    return 1;
+  }
   if (0 != ret)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Global status indicates unsuccessful testrun - probably allocation_cb was not called.\n");
-      ret = 77; // SKIP test, test not yet right!
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Global status indicates unsuccessful testrun - probably allocation_cb was not called.\n");
+    ret = 77;   // SKIP test, test not yet right!
+  }
   return ret;
 }
 
diff --git a/src/ats/test_ats2_lib.h b/src/ats/test_ats2_lib.h
index f6d4d45b0..090abc20d 100644
--- a/src/ats/test_ats2_lib.h
+++ b/src/ats/test_ats2_lib.h
@@ -32,8 +32,8 @@
 ///**
 // * Commands for the interpreter.
 // */
-//enum CommandCode
-//{
+// enum CommandCode
+// {
 //  /**
 //   * End the test (passing).
 //   */
@@ -123,14 +123,14 @@
 //   */
 //  CMD_SLEEP
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_ADD_ADDRESS command.
 // */
-//struct CommandAddAddress
-//{
+// struct CommandAddAddress
+// {
 //  /**
 //   * Number of the peer (used to generate PID).
 //   */
@@ -165,27 +165,27 @@
 //   * Here the result of the add address operation will be stored.
 //   */
 //  struct GNUNET_ATS_AddressRecord *ar;
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_DEL_ADDRESS command.
 // */
-//struct CommandDelAddress
-//{
+// struct CommandDelAddress
+// {
 //  /**
 //   * Label of the corresponding #CMD_ADD_ADDRESS that
 //   * we are now to remove.
 //   */
 //  const char *add_label;
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_AWAIT_ADDRESS_SUGGESTION command.
 // */
-//struct CommandAwaitAddressSuggestion
-//{
+// struct CommandAwaitAddressSuggestion
+// {
 //  /**
 //   * For which peer do we expect a suggestion?
 //   */
@@ -198,27 +198,27 @@
 //   */
 //  const char *add_label;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_AWAIT_DISCONNECT_SUGGESTION command.
 // */
-//struct CommandAwaitDisconnectSuggestion
-//{
+// struct CommandAwaitDisconnectSuggestion
+// {
 //  /**
 //   * For which peer do we expect the disconnect?
 //   */
 //  unsigned int pid;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_REQUEST_CONNECTION_START command.
 // */
-//struct CommandRequestConnectionStart
-//{
+// struct CommandRequestConnectionStart
+// {
 //  /**
 //   * Identity of the peer we would like to connect to.
 //   */
@@ -229,27 +229,27 @@
 //   * #GNUNET_ATS_connectivity_suggest().
 //   */
 //  struct GNUNET_ATS_ConnectivitySuggestHandle *csh;
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_REQUEST_CONNECTION_STOP command.
 // */
-//struct CommandRequestConnectionStop
-//{
+// struct CommandRequestConnectionStop
+// {
 //  /**
 //   * Label of the corresponding #CMD_REQUEST_CONNECTION_START that
 //   * we are now stopping.
 //   */
 //  const char *connect_label;
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_AWAIT_ADDRESS_INFORMATION command.
 // */
-//struct CommandAwaitAddressInformation
-//{
+// struct CommandAwaitAddressInformation
+// {
 //  /**
 //   * For which address do we expect information?
 //   * The address is identified by the respective
@@ -264,14 +264,14 @@
 //   */
 //  const char *update_label;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_UPDATE_ADDRESS command.
 // */
-//struct CommandUpdateAddress
-//{
+// struct CommandUpdateAddress
+// {
 //  /**
 //   * Label of the addresses's add operation.
 //   */
@@ -282,14 +282,14 @@
 //   */
 //  struct GNUNET_ATS_Properties properties;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_ADD_SESSION command.
 // */
-//struct CommandAddSession
-//{
+// struct CommandAddSession
+// {
 // /**
 //   * Label of the addresses's add operation.
 //   */
@@ -300,27 +300,27 @@
 //   */
 //  unsigned int session;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_DEL_SESSION command.
 // */
-//struct CommandDelSession
-//{
+// struct CommandDelSession
+// {
 // /**
 //   * Label of the addresses's add operation.
 //   */
 //  const char *add_session_label;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_CHANGE_PREFERENCE command.
 // */
-//struct CommandChangePreference
-//{
+// struct CommandChangePreference
+// {
 //  /**
 //   * Identity of the peer we have a preference change towards.
 //   */
@@ -328,14 +328,14 @@
 //
 //  /* FIXME: preference details! */
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_PROVIDE_FEEDBACK command.
 // */
-//struct CommandProvideFeedback
-//{
+// struct CommandProvideFeedback
+// {
 //  /**
 //   * Identity of the peer we have a feedback for.
 //   */
@@ -347,14 +347,14 @@
 //  struct GNUNET_TIME_Relative scope;
 //
 //  /* FIXME: feedback details! */
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_LIST_ADDRESSES command.
 // */
-//struct CommandListAddresses
-//{
+// struct CommandListAddresses
+// {
 //  /**
 //   * Identity of the peer we want a list for.
 //   */
@@ -403,14 +403,14 @@
 //   */
 //  struct GNUNET_ATS_AddressListHandle *alh;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_RESERVE_BANDWIDTH command.
 // */
-//struct CommandReserveBandwidth
-//{
+// struct CommandReserveBandwidth
+// {
 //  /**
 //   * For which peer do we reserve bandwidth?
 //   */
@@ -435,26 +435,26 @@
 //   */
 //  struct GNUNET_ATS_ReservationContext *rc;
 //
-//};
+// };
 //
 //
 ///**
 // * Details for the #CMD_SLEEP command.
 // */
-//struct CommandSleep
-//{
+// struct CommandSleep
+// {
 //  /**
 //   * How long should we wait before running the next command?
 //   */
 //  struct GNUNET_TIME_Relative delay;
-//};
+// };
 //
 //
 ///**
 // * A command for the test case interpreter.
 // */
-//struct Command
-//{
+// struct Command
+// {
 //  /**
 //   * Command code to run.
 //   */
@@ -502,7 +502,7 @@
 //
 //  } details;
 //
-//};
+// };
 
 
 /**
@@ -515,9 +515,9 @@
  * @return 0 on success
  */
 int
-TEST_ATS_run(int argc,
-             char *argv[],
-             struct Command *cmds,
-             struct GNUNET_TIME_Relative timeout);
+TEST_ATS_run (int argc,
+              char *argv[],
+              struct Command *cmds,
+              struct GNUNET_TIME_Relative timeout);
 
 #endif
diff --git a/src/ats/test_ats_api.c b/src/ats/test_ats_api.c
index bc703a111..0ec1bbdef 100644
--- a/src/ats/test_ats_api.c
+++ b/src/ats/test_ats_api.c
@@ -28,7 +28,7 @@
 /**
  * Global timeout for the testcase.
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 3)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3)
 
 /**
  * Definition of the test as a sequence of commands.
@@ -233,13 +233,13 @@ static struct Command test_commands[] = {
 
 
 int
-main(int argc,
-     char *argv[])
+main (int argc,
+      char *argv[])
 {
-  return TEST_ATS_run(argc,
-                      argv,
-                      test_commands,
-                      TIMEOUT);
+  return TEST_ATS_run (argc,
+                       argv,
+                       test_commands,
+                       TIMEOUT);
 }
 
 
diff --git a/src/ats/test_ats_lib.c b/src/ats/test_ats_lib.c
index 979dbde3e..cd512634d 100644
--- a/src/ats/test_ats_lib.c
+++ b/src/ats/test_ats_lib.c
@@ -31,7 +31,8 @@
 /**
  * Information about the last address suggestion we got for a peer.
  */
-struct AddressSuggestData {
+struct AddressSuggestData
+{
   /**
    * Which session were we given?
    */
@@ -62,7 +63,8 @@ struct AddressSuggestData {
 /**
  * Information about the last address information we got for an address.
  */
-struct AddressInformationData {
+struct AddressInformationData
+{
   /**
    * What address is this data about?
    */
@@ -154,18 +156,18 @@ static struct Command *test_commands;
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_asd(void *cls,
-         const struct GNUNET_PeerIdentity *key,
-         void *value)
+free_asd (void *cls,
+          const struct GNUNET_PeerIdentity *key,
+          void *value)
 {
   struct AddressSuggestData *asd = value;
 
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(p2asd,
-                                                     key,
-                                                     asd));
-  GNUNET_free_non_null(asd->address);
-  GNUNET_free(asd);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (p2asd,
+                                                       key,
+                                                       asd));
+  GNUNET_free_non_null (asd->address);
+  GNUNET_free (asd);
   return GNUNET_OK;
 }
 
@@ -179,18 +181,18 @@ free_asd(void *cls,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-free_aid(void *cls,
-         const struct GNUNET_PeerIdentity *key,
-         void *value)
+free_aid (void *cls,
+          const struct GNUNET_PeerIdentity *key,
+          void *value)
 {
   struct AddressInformationData *aid = value;
 
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(p2aid,
-                                                     key,
-                                                     aid));
-  GNUNET_free(aid->address);
-  GNUNET_free(aid);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (p2aid,
+                                                       key,
+                                                       aid));
+  GNUNET_free (aid->address);
+  GNUNET_free (aid);
   return GNUNET_OK;
 }
 
@@ -202,17 +204,18 @@ free_aid(void *cls,
  * @return NULL if peer was never involved
  */
 static struct AddressSuggestData *
-find_address_suggestion(const struct GNUNET_PeerIdentity *pid)
+find_address_suggestion (const struct GNUNET_PeerIdentity *pid)
 {
-  return GNUNET_CONTAINER_multipeermap_get(p2asd,
-                                           pid);
+  return GNUNET_CONTAINER_multipeermap_get (p2asd,
+                                            pid);
 }
 
 
 /**
  * Closure for #match_address()
  */
-struct MatchAddressContext {
+struct MatchAddressContext
+{
   /**
    * Address to find.
    */
@@ -234,19 +237,19 @@ struct MatchAddressContext {
  * @return #GNUNET_OK if not found
  */
 static int
-match_address(void *cls,
-              const struct GNUNET_PeerIdentity *key,
-              void *value)
+match_address (void *cls,
+               const struct GNUNET_PeerIdentity *key,
+               void *value)
 {
   struct MatchAddressContext *mac = cls;
   struct AddressInformationData *aid = value;
 
-  if (0 == GNUNET_HELLO_address_cmp(mac->addr,
-                                    aid->address))
-    {
-      mac->ret = aid;
-      return GNUNET_NO;
-    }
+  if (0 == GNUNET_HELLO_address_cmp (mac->addr,
+                                     aid->address))
+  {
+    mac->ret = aid;
+    return GNUNET_NO;
+  }
   return GNUNET_OK;
 }
 
@@ -258,16 +261,16 @@ match_address(void *cls,
  * @return NULL if peer was never involved
  */
 static struct AddressInformationData *
-find_address_information(const struct GNUNET_HELLO_Address *addr)
+find_address_information (const struct GNUNET_HELLO_Address *addr)
 {
   struct MatchAddressContext mac;
 
   mac.ret = NULL;
   mac.addr = addr;
-  GNUNET_CONTAINER_multipeermap_get_multiple(p2aid,
-                                             &addr->peer,
-                                             &match_address,
-                                             &mac);
+  GNUNET_CONTAINER_multipeermap_get_multiple (p2aid,
+                                              &addr->peer,
+                                              &match_address,
+                                              &mac);
   return mac.ret;
 }
 
@@ -278,51 +281,51 @@ find_address_information(const struct GNUNET_HELLO_Address *addr)
  * @param cls NULL
  */
 static void
-end(void *cls)
+end (void *cls)
 {
   if (0 != ret)
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-               "Test failed at stage %u %s\n",
-               off,
-               (NULL != test_commands[off].label)
-               ? test_commands[off].label
-               : "");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Test failed at stage %u %s\n",
+                off,
+                (NULL != test_commands[off].label)
+                ? test_commands[off].label
+                : "");
   if (NULL != interpreter_task)
-    {
-      GNUNET_SCHEDULER_cancel(interpreter_task);
-      interpreter_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (interpreter_task);
+    interpreter_task = NULL;
+  }
   if (NULL != sched_ats)
-    {
-      GNUNET_ATS_scheduling_done(sched_ats);
-      sched_ats = NULL;
-    }
+  {
+    GNUNET_ATS_scheduling_done (sched_ats);
+    sched_ats = NULL;
+  }
   if (NULL != con_ats)
-    {
-      GNUNET_ATS_connectivity_done(con_ats);
-      con_ats = NULL;
-    }
+  {
+    GNUNET_ATS_connectivity_done (con_ats);
+    con_ats = NULL;
+  }
   if (NULL != perf_ats)
-    {
-      GNUNET_ATS_performance_done(perf_ats);
-      perf_ats = NULL;
-    }
+  {
+    GNUNET_ATS_performance_done (perf_ats);
+    perf_ats = NULL;
+  }
   if (NULL != p2asd)
-    {
-      GNUNET_CONTAINER_multipeermap_iterate(p2asd,
-                                            &free_asd,
-                                            NULL);
-      GNUNET_CONTAINER_multipeermap_destroy(p2asd);
-      p2asd = NULL;
-    }
+  {
+    GNUNET_CONTAINER_multipeermap_iterate (p2asd,
+                                           &free_asd,
+                                           NULL);
+    GNUNET_CONTAINER_multipeermap_destroy (p2asd);
+    p2asd = NULL;
+  }
   if (NULL != p2aid)
-    {
-      GNUNET_CONTAINER_multipeermap_iterate(p2aid,
-                                            &free_aid,
-                                            NULL);
-      GNUNET_CONTAINER_multipeermap_destroy(p2aid);
-      p2aid = NULL;
-    }
+  {
+    GNUNET_CONTAINER_multipeermap_iterate (p2aid,
+                                           &free_aid,
+                                           NULL);
+    GNUNET_CONTAINER_multipeermap_destroy (p2aid);
+    p2aid = NULL;
+  }
 }
 
 
@@ -332,19 +335,19 @@ end(void *cls)
  * @param cls NULL
  */
 static void
-interpreter(void *cls);
+interpreter (void *cls);
 
 
 /**
  * Run the interpreter next.
  */
 static void
-run_interpreter()
+run_interpreter ()
 {
   if (NULL != interpreter_task)
-    GNUNET_SCHEDULER_cancel(interpreter_task);
-  interpreter_task = GNUNET_SCHEDULER_add_now(&interpreter,
-                                              NULL);
+    GNUNET_SCHEDULER_cancel (interpreter_task);
+  interpreter_task = GNUNET_SCHEDULER_add_now (&interpreter,
+                                               NULL);
 }
 
 
@@ -355,15 +358,15 @@ run_interpreter()
  * @param pk resulting fake public key
  */
 static void
-make_peer(uint32_t pid,
-          struct GNUNET_PeerIdentity *pk)
+make_peer (uint32_t pid,
+           struct GNUNET_PeerIdentity *pk)
 {
-  memset(pk,
-         (int)pid,
-         sizeof(struct GNUNET_PeerIdentity));
-  GNUNET_memcpy(pk,
-                &pid,
-                sizeof(uint32_t));
+  memset (pk,
+          (int) pid,
+          sizeof(struct GNUNET_PeerIdentity));
+  GNUNET_memcpy (pk,
+                 &pid,
+                 sizeof(uint32_t));
 }
 
 
@@ -376,28 +379,29 @@ make_peer(uint32_t pid,
  * @return the address
  */
 static struct GNUNET_HELLO_Address *
-make_address(uint32_t pid,
-             uint32_t num,
-             enum GNUNET_HELLO_AddressInfo addr_flags)
+make_address (uint32_t pid,
+              uint32_t num,
+              enum GNUNET_HELLO_AddressInfo addr_flags)
 {
   struct GNUNET_PeerIdentity pk;
   uint32_t nbo;
 
-  nbo = htonl(num);
-  make_peer(pid,
-            &pk);
-  return GNUNET_HELLO_address_allocate(&pk,
-                                       "test",
-                                       &nbo,
-                                       sizeof(nbo),
-                                       addr_flags);
+  nbo = htonl (num);
+  make_peer (pid,
+             &pk);
+  return GNUNET_HELLO_address_allocate (&pk,
+                                        "test",
+                                        &nbo,
+                                        sizeof(nbo),
+                                        addr_flags);
 }
 
 
 /**
  * Our dummy sessions.
  */
-struct GNUNET_ATS_Session {
+struct GNUNET_ATS_Session
+{
   /**
    * Field to avoid `0 == sizeof(struct GNUNET_ATS_Session)`.
    */
@@ -412,7 +416,7 @@ struct GNUNET_ATS_Session {
  * @return NULL if @a i is 0, otherwise a pointer unique to @a i
  */
 static struct GNUNET_ATS_Session *
-make_session(unsigned int i)
+make_session (unsigned int i)
 {
   struct GNUNET_ATS_Session *baseptr = NULL;
 
@@ -434,8 +438,8 @@ make_session(unsigned int i)
  * @return previous command with the matching label
  */
 static struct Command *
-find_command(enum CommandCode code,
-             const char *label)
+find_command (enum CommandCode code,
+              const char *label)
 {
   int i;
 
@@ -443,10 +447,10 @@ find_command(enum CommandCode code,
     return NULL;
   for (i = off - 1; i >= 0; i--)
     if ((code == test_commands[i].code) &&
-        (0 == strcmp(test_commands[i].label,
-                     label)))
+        (0 == strcmp (test_commands[i].label,
+                      label)))
       return &test_commands[i];
-  GNUNET_break(0);
+  GNUNET_break (0);
   return NULL;
 }
 
@@ -466,53 +470,53 @@ find_command(enum CommandCode code,
  * @param prop performance data for the address
  */
 static void
-info_cb(void *cls,
-        const struct GNUNET_HELLO_Address *address,
-        int address_active,
-        struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-        struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
-        const struct GNUNET_ATS_Properties *prop)
+info_cb (void *cls,
+         const struct GNUNET_HELLO_Address *address,
+         int address_active,
+         struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+         struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+         const struct GNUNET_ATS_Properties *prop)
 {
   struct Command *c = cls;
   struct CommandListAddresses *cmd = &c->details.list_addresses;
 
   if (NULL == address)
+  {
+    cmd->alh = NULL;
+    /* we are done with the iteration, continue to execute */
+    if ((cmd->calls < cmd->min_calls) &&
+        (cmd->active_calls < cmd->min_active_calls))
     {
-      cmd->alh = NULL;
-      /* we are done with the iteration, continue to execute */
-      if ((cmd->calls < cmd->min_calls) &&
-          (cmd->active_calls < cmd->min_active_calls))
-        {
-          GNUNET_SCHEDULER_shutdown();
-          return;
-        }
-      off++;
-      run_interpreter();
+      GNUNET_SCHEDULER_shutdown ();
       return;
     }
+    off++;
+    run_interpreter ();
+    return;
+  }
   switch (address_active)
-    {
-    case GNUNET_YES:
-      cmd->active_calls++;
-      cmd->calls++;
-      break;
-
-    case GNUNET_NO:
-      cmd->calls++;
-      break;
-
-    case GNUNET_SYSERR:
-      return;
-    }
+  {
+  case GNUNET_YES:
+    cmd->active_calls++;
+    cmd->calls++;
+    break;
+
+  case GNUNET_NO:
+    cmd->calls++;
+    break;
+
+  case GNUNET_SYSERR:
+    return;
+  }
   if ((cmd->calls > cmd->max_calls) &&
       (cmd->active_calls < cmd->max_active_calls))
-    {
-      GNUNET_break(0);
-      GNUNET_ATS_performance_list_addresses_cancel(cmd->alh);
-      cmd->alh = NULL;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_ATS_performance_list_addresses_cancel (cmd->alh);
+    cmd->alh = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 }
 
 
@@ -527,58 +531,58 @@ info_cb(void *cls,
  *        long should the client wait until re-trying?
  */
 static void
-reservation_cb(void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               int32_t amount,
-               struct GNUNET_TIME_Relative res_delay)
+reservation_cb (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                int32_t amount,
+                struct GNUNET_TIME_Relative res_delay)
 {
   struct Command *cmd = cls;
   struct GNUNET_PeerIdentity pid;
 
   cmd->details.reserve_bandwidth.rc = NULL;
-  make_peer(cmd->details.reserve_bandwidth.pid,
-            &pid);
-  GNUNET_assert(0 == GNUNET_memcmp(peer,
-                                   &pid));
+  make_peer (cmd->details.reserve_bandwidth.pid,
+             &pid);
+  GNUNET_assert (0 == GNUNET_memcmp (peer,
+                                     &pid));
   switch (cmd->details.reserve_bandwidth.expected_result)
+  {
+  case GNUNET_OK:
+    if (amount != cmd->details.reserve_bandwidth.amount)
     {
-    case GNUNET_OK:
-      if (amount != cmd->details.reserve_bandwidth.amount)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Unexpectedly failed to reserve %d/%d bytes with delay %s!\n",
-                     (int)amount,
-                     (int)cmd->details.reserve_bandwidth.amount,
-                     GNUNET_STRINGS_relative_time_to_string(res_delay,
-                                                            GNUNET_YES));
-          GNUNET_break(0);
-          GNUNET_SCHEDULER_shutdown();
-          return;
-        }
-      break;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Unexpectedly failed to reserve %d/%d bytes with delay %s!\n",
+                  (int) amount,
+                  (int) cmd->details.reserve_bandwidth.amount,
+                  GNUNET_STRINGS_relative_time_to_string (res_delay,
+                                                          GNUNET_YES));
+      GNUNET_break (0);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    break;
 
-    case GNUNET_NO:
-      GNUNET_break((0 != amount) ||
-                   (0 != res_delay.rel_value_us));
-      break;
+  case GNUNET_NO:
+    GNUNET_break ((0 != amount) ||
+                  (0 != res_delay.rel_value_us));
+    break;
 
-    case GNUNET_SYSERR:
-      if ((amount != 0) ||
-          (0 == res_delay.rel_value_us))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Unexpectedly reserved %d bytes with delay %s!\n",
-                     (int)amount,
-                     GNUNET_STRINGS_relative_time_to_string(res_delay,
-                                                            GNUNET_YES));
-          GNUNET_break(0);
-          GNUNET_SCHEDULER_shutdown();
-          return;
-        }
-      break;
+  case GNUNET_SYSERR:
+    if ((amount != 0) ||
+        (0 == res_delay.rel_value_us))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Unexpectedly reserved %d bytes with delay %s!\n",
+                  (int) amount,
+                  GNUNET_STRINGS_relative_time_to_string (res_delay,
+                                                          GNUNET_YES));
+      GNUNET_break (0);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
     }
+    break;
+  }
   off++;
-  run_interpreter();
+  run_interpreter ();
 }
 
 
@@ -588,297 +592,301 @@ reservation_cb(void *cls,
  * @param cls NULL
  */
 static void
-interpreter(void *cls)
+interpreter (void *cls)
 
 {
   struct Command *cmd;
 
   interpreter_task = NULL;
   while (1)
+  {
+    cmd = &test_commands[off];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "#%u: %d %s\n",
+                off,
+                (int) cmd->code,
+                (NULL != cmd->label) ? cmd->label : "");
+    switch (cmd->code)
     {
-      cmd = &test_commands[off];
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "#%u: %d %s\n",
-                 off,
-                 (int)cmd->code,
-                 (NULL != cmd->label) ? cmd->label : "");
-      switch (cmd->code)
-        {
-        case CMD_END_PASS:
-          ret = 0;
-          GNUNET_SCHEDULER_shutdown();
-          return;
-
-        case CMD_ADD_ADDRESS:
-        {
-          struct GNUNET_HELLO_Address *addr;
-          struct GNUNET_ATS_Session *session;
-
-          addr = make_address(cmd->details.add_address.pid,
-                              cmd->details.add_address.addr_num,
-                              cmd->details.add_address.addr_flags);
-          session = make_session(cmd->details.add_address.session);
-          if (cmd->details.add_address.expect_fail)
-            GNUNET_log_skip(1, GNUNET_NO);
-          cmd->details.add_address.ar
-            = GNUNET_ATS_address_add(sched_ats,
-                                     addr,
-                                     session,
-                                     &cmd->details.add_address.properties);
-          GNUNET_free(addr);
-          if (cmd->details.add_address.expect_fail)
-            {
-              GNUNET_log_skip(0, GNUNET_YES);
-            }
-          else if (NULL == cmd->details.add_address.ar)
-            {
-              GNUNET_break(0);
-              GNUNET_SCHEDULER_shutdown();
-              return;
-            }
-          off++;
-          break;
-        }
-
-        case CMD_DEL_ADDRESS:
-        {
-          struct Command *add;
-
-          add = find_command(CMD_ADD_ADDRESS,
-                             cmd->details.del_address.add_label);
-          GNUNET_assert(NULL != add->details.add_address.ar);
-          GNUNET_ATS_address_destroy(add->details.add_address.ar);
-          add->details.add_address.ar = NULL;
-          off++;
-          break;
-        }
-
-        case CMD_AWAIT_ADDRESS_SUGGESTION:
-        {
-          struct GNUNET_PeerIdentity pid;
-          struct GNUNET_HELLO_Address *addr;
-          struct Command *add;
-          struct AddressSuggestData *asd;
-          int done;
-
-          make_peer(cmd->details.await_address_suggestion.pid,
-                    &pid);
-          asd = find_address_suggestion(&pid);
-          if (NULL == asd)
-            return;
-          if (GNUNET_NO == asd->active)
-            return; /* last suggestion was to disconnect, wait longer */
-          done = GNUNET_YES;
-          if (NULL != cmd->details.await_address_suggestion.add_label)
-            {
-              done = GNUNET_NO;
-              add = find_command(CMD_ADD_ADDRESS,
-                                 cmd->details.await_address_suggestion.add_label);
-              addr = make_address(add->details.add_address.pid,
-                                  add->details.add_address.addr_num,
-                                  add->details.add_address.addr_flags);
-              if ((asd->session ==
-                   make_session(add->details.add_address.session)) &&
-                  (0 ==
-                   GNUNET_HELLO_address_cmp(addr,
-                                            asd->address)))
-                done = GNUNET_YES;
-              GNUNET_free(addr);
-            }
-          if (GNUNET_NO == done)
-            return;
-          off++;
-          break;
-        }
-
-        case CMD_AWAIT_DISCONNECT_SUGGESTION:
-        {
-          struct GNUNET_PeerIdentity pid;
-          struct AddressSuggestData *asd;
-
-          make_peer(cmd->details.await_disconnect_suggestion.pid,
-                    &pid);
-          asd = find_address_suggestion(&pid);
-          if (NULL == asd)
-            return; /* odd, no suggestion at all yet!? */
-          if (GNUNET_YES == asd->active)
-            return; /* last suggestion was to activate, wait longer */
-          /* last suggestion was to deactivate, condition satisfied! */
-          off++;
-          break;
-        }
-
-        case CMD_REQUEST_CONNECTION_START:
-        {
-          struct GNUNET_PeerIdentity pid;
-
-          make_peer(cmd->details.request_connection_start.pid,
-                    &pid);
-          cmd->details.request_connection_start.csh
-            = GNUNET_ATS_connectivity_suggest(con_ats,
-                                              &pid,
-                                              1);
-          off++;
-          break;
-        }
+    case CMD_END_PASS:
+      ret = 0;
+      GNUNET_SCHEDULER_shutdown ();
+      return;
 
-        case CMD_REQUEST_CONNECTION_STOP:
+    case CMD_ADD_ADDRESS:
+      {
+        struct GNUNET_HELLO_Address *addr;
+        struct GNUNET_ATS_Session *session;
+
+        addr = make_address (cmd->details.add_address.pid,
+                             cmd->details.add_address.addr_num,
+                             cmd->details.add_address.addr_flags);
+        session = make_session (cmd->details.add_address.session);
+        if (cmd->details.add_address.expect_fail)
+          GNUNET_log_skip (1, GNUNET_NO);
+        cmd->details.add_address.ar
+          = GNUNET_ATS_address_add (sched_ats,
+                                    addr,
+                                    session,
+                                    &cmd->details.add_address.properties);
+        GNUNET_free (addr);
+        if (cmd->details.add_address.expect_fail)
         {
-          struct Command *start;
-
-          start = find_command(CMD_REQUEST_CONNECTION_START,
-                               cmd->details.request_connection_stop.connect_label);
-          GNUNET_ATS_connectivity_suggest_cancel(start->details.request_connection_start.csh);
-          start->details.request_connection_start.csh = NULL;
-          off++;
-          break;
+          GNUNET_log_skip (0, GNUNET_YES);
         }
-
-        case CMD_AWAIT_ADDRESS_INFORMATION:
+        else if (NULL == cmd->details.add_address.ar)
         {
-          struct AddressInformationData *aid;
-          struct Command *add;
-          struct Command *update;
-          struct GNUNET_HELLO_Address *addr;
-          const struct GNUNET_ATS_Properties *cmp;
-
-          add = find_command(CMD_ADD_ADDRESS,
-                             cmd->details.await_address_information.add_label);
-          update = find_command(CMD_UPDATE_ADDRESS,
-                                cmd->details.await_address_information.update_label);
-          addr = make_address(add->details.add_address.pid,
-                              add->details.add_address.addr_num,
-                              add->details.add_address.addr_flags);
-          aid = find_address_information(addr);
-          GNUNET_free(addr);
-          if (NULL == update)
-            cmp = &add->details.add_address.properties;
-          else
-            cmp = &update->details.update_address.properties;
-          if ((NULL != aid) &&
-              (cmp->delay.rel_value_us == aid->properties.delay.rel_value_us) &&
-              (cmp->utilization_out == aid->properties.utilization_out) &&
-              (cmp->utilization_in == aid->properties.utilization_in) &&
-              (cmp->distance == aid->properties.distance) &&
-              (cmp->scope == aid->properties.scope))
-            {
-              off++;
-              break;
-            }
+          GNUNET_break (0);
+          GNUNET_SCHEDULER_shutdown ();
           return;
         }
-
-        case CMD_UPDATE_ADDRESS:
+        off++;
+        break;
+      }
+
+    case CMD_DEL_ADDRESS:
+      {
+        struct Command *add;
+
+        add = find_command (CMD_ADD_ADDRESS,
+                            cmd->details.del_address.add_label);
+        GNUNET_assert (NULL != add->details.add_address.ar);
+        GNUNET_ATS_address_destroy (add->details.add_address.ar);
+        add->details.add_address.ar = NULL;
+        off++;
+        break;
+      }
+
+    case CMD_AWAIT_ADDRESS_SUGGESTION:
+      {
+        struct GNUNET_PeerIdentity pid;
+        struct GNUNET_HELLO_Address *addr;
+        struct Command *add;
+        struct AddressSuggestData *asd;
+        int done;
+
+        make_peer (cmd->details.await_address_suggestion.pid,
+                   &pid);
+        asd = find_address_suggestion (&pid);
+        if (NULL == asd)
+          return;
+        if (GNUNET_NO == asd->active)
+          return;   /* last suggestion was to disconnect, wait longer */
+        done = GNUNET_YES;
+        if (NULL != cmd->details.await_address_suggestion.add_label)
         {
-          struct Command *add;
-
-          add = find_command(CMD_ADD_ADDRESS,
-                             cmd->details.update_address.add_label);
-          GNUNET_assert(NULL != add->details.add_address.ar);
-          GNUNET_ATS_address_update(add->details.add_address.ar,
-                                    &cmd->details.update_address.properties);
-          off++;
-          break;
+          done = GNUNET_NO;
+          add = find_command (CMD_ADD_ADDRESS,
+                              cmd->details.await_address_suggestion.add_label);
+          addr = make_address (add->details.add_address.pid,
+                               add->details.add_address.addr_num,
+                               add->details.add_address.addr_flags);
+          if ((asd->session ==
+               make_session (add->details.add_address.session)) &&
+              (0 ==
+               GNUNET_HELLO_address_cmp (addr,
+                                         asd->address)))
+            done = GNUNET_YES;
+          GNUNET_free (addr);
         }
-
-        case CMD_ADD_SESSION:
-        {
-          struct Command *add;
-          struct GNUNET_ATS_Session *session;
-
-          add = find_command(CMD_ADD_ADDRESS,
-                             cmd->details.add_session.add_label);
-          session = make_session(cmd->details.add_session.session);
-          GNUNET_assert(NULL != add->details.add_address.ar);
-          GNUNET_ATS_address_add_session(add->details.add_address.ar,
-                                         session);
-          off++;
-          break;
-        }
-
-        case CMD_DEL_SESSION:
+        if (GNUNET_NO == done)
+          return;
+        off++;
+        break;
+      }
+
+    case CMD_AWAIT_DISCONNECT_SUGGESTION:
+      {
+        struct GNUNET_PeerIdentity pid;
+        struct AddressSuggestData *asd;
+
+        make_peer (cmd->details.await_disconnect_suggestion.pid,
+                   &pid);
+        asd = find_address_suggestion (&pid);
+        if (NULL == asd)
+          return;   /* odd, no suggestion at all yet!? */
+        if (GNUNET_YES == asd->active)
+          return;   /* last suggestion was to activate, wait longer */
+        /* last suggestion was to deactivate, condition satisfied! */
+        off++;
+        break;
+      }
+
+    case CMD_REQUEST_CONNECTION_START:
+      {
+        struct GNUNET_PeerIdentity pid;
+
+        make_peer (cmd->details.request_connection_start.pid,
+                   &pid);
+        cmd->details.request_connection_start.csh
+          = GNUNET_ATS_connectivity_suggest (con_ats,
+                                             &pid,
+                                             1);
+        off++;
+        break;
+      }
+
+    case CMD_REQUEST_CONNECTION_STOP:
+      {
+        struct Command *start;
+
+        start = find_command (CMD_REQUEST_CONNECTION_START,
+                              cmd->details.request_connection_stop.connect_label);
+        GNUNET_ATS_connectivity_suggest_cancel (
+          start->details.request_connection_start.csh);
+        start->details.request_connection_start.csh = NULL;
+        off++;
+        break;
+      }
+
+    case CMD_AWAIT_ADDRESS_INFORMATION:
+      {
+        struct AddressInformationData *aid;
+        struct Command *add;
+        struct Command *update;
+        struct GNUNET_HELLO_Address *addr;
+        const struct GNUNET_ATS_Properties *cmp;
+
+        add = find_command (CMD_ADD_ADDRESS,
+                            cmd->details.await_address_information.add_label);
+        update = find_command (CMD_UPDATE_ADDRESS,
+                               cmd->details.await_address_information.
+                               update_label);
+        addr = make_address (add->details.add_address.pid,
+                             add->details.add_address.addr_num,
+                             add->details.add_address.addr_flags);
+        aid = find_address_information (addr);
+        GNUNET_free (addr);
+        if (NULL == update)
+          cmp = &add->details.add_address.properties;
+        else
+          cmp = &update->details.update_address.properties;
+        if ((NULL != aid) &&
+            (cmp->delay.rel_value_us == aid->properties.delay.rel_value_us) &&
+            (cmp->utilization_out == aid->properties.utilization_out) &&
+            (cmp->utilization_in == aid->properties.utilization_in) &&
+            (cmp->distance == aid->properties.distance) &&
+            (cmp->scope == aid->properties.scope))
         {
-          struct Command *add_address;
-          struct Command *add_session;
-          struct GNUNET_ATS_Session *session;
-
-          add_session = find_command(CMD_ADD_SESSION,
-                                     cmd->details.del_session.add_session_label);
-          add_address = find_command(CMD_ADD_ADDRESS,
-                                     add_session->details.add_session.add_label);
-          GNUNET_assert(NULL != add_address->details.add_address.ar);
-          session = make_session(add_session->details.add_session.session);
-          GNUNET_ATS_address_del_session(add_address->details.add_address.ar,
-                                         session);
           off++;
           break;
         }
-
-        case CMD_CHANGE_PREFERENCE:
-        {
-          struct GNUNET_PeerIdentity pid;
-
-          make_peer(cmd->details.change_preference.pid,
-                    &pid);
-          GNUNET_ATS_performance_change_preference(perf_ats,
+        return;
+      }
+
+    case CMD_UPDATE_ADDRESS:
+      {
+        struct Command *add;
+
+        add = find_command (CMD_ADD_ADDRESS,
+                            cmd->details.update_address.add_label);
+        GNUNET_assert (NULL != add->details.add_address.ar);
+        GNUNET_ATS_address_update (add->details.add_address.ar,
+                                   &cmd->details.update_address.properties);
+        off++;
+        break;
+      }
+
+    case CMD_ADD_SESSION:
+      {
+        struct Command *add;
+        struct GNUNET_ATS_Session *session;
+
+        add = find_command (CMD_ADD_ADDRESS,
+                            cmd->details.add_session.add_label);
+        session = make_session (cmd->details.add_session.session);
+        GNUNET_assert (NULL != add->details.add_address.ar);
+        GNUNET_ATS_address_add_session (add->details.add_address.ar,
+                                        session);
+        off++;
+        break;
+      }
+
+    case CMD_DEL_SESSION:
+      {
+        struct Command *add_address;
+        struct Command *add_session;
+        struct GNUNET_ATS_Session *session;
+
+        add_session = find_command (CMD_ADD_SESSION,
+                                    cmd->details.del_session.add_session_label);
+        add_address = find_command (CMD_ADD_ADDRESS,
+                                    add_session->details.add_session.add_label);
+        GNUNET_assert (NULL != add_address->details.add_address.ar);
+        session = make_session (add_session->details.add_session.session);
+        GNUNET_ATS_address_del_session (add_address->details.add_address.ar,
+                                        session);
+        off++;
+        break;
+      }
+
+    case CMD_CHANGE_PREFERENCE:
+      {
+        struct GNUNET_PeerIdentity pid;
+
+        make_peer (cmd->details.change_preference.pid,
+                   &pid);
+        GNUNET_ATS_performance_change_preference (perf_ats,
+                                                  &pid,
+                                                  GNUNET_ATS_PREFERENCE_END);
+        off++;
+        break;
+      }
+
+    case CMD_PROVIDE_FEEDBACK:
+      {
+        struct GNUNET_PeerIdentity pid;
+
+        make_peer (cmd->details.provide_feedback.pid,
+                   &pid);
+        GNUNET_ATS_performance_give_feedback (perf_ats,
+                                              &pid,
+                                              cmd->details.provide_feedback.
+                                              scope,
+                                              GNUNET_ATS_PREFERENCE_END);
+        off++;
+        break;
+      }
+
+    case CMD_LIST_ADDRESSES:
+      {
+        struct GNUNET_PeerIdentity pid;
+
+        make_peer (cmd->details.list_addresses.pid,
+                   &pid);
+        cmd->details.list_addresses.alh
+          = GNUNET_ATS_performance_list_addresses (perf_ats,
                                                    &pid,
-                                                   GNUNET_ATS_PREFERENCE_END);
-          off++;
-          break;
-        }
-
-        case CMD_PROVIDE_FEEDBACK:
-        {
-          struct GNUNET_PeerIdentity pid;
-
-          make_peer(cmd->details.provide_feedback.pid,
-                    &pid);
-          GNUNET_ATS_performance_give_feedback(perf_ats,
-                                               &pid,
-                                               cmd->details.provide_feedback.scope,
-                                               GNUNET_ATS_PREFERENCE_END);
-          off++;
-          break;
-        }
-
-        case CMD_LIST_ADDRESSES:
-        {
-          struct GNUNET_PeerIdentity pid;
-
-          make_peer(cmd->details.list_addresses.pid,
-                    &pid);
-          cmd->details.list_addresses.alh
-            = GNUNET_ATS_performance_list_addresses(perf_ats,
-                                                    &pid,
-                                                    cmd->details.list_addresses.all,
-                                                    &info_cb,
-                                                    cmd);
-          return;
-        }
-
-        case CMD_RESERVE_BANDWIDTH:
-        {
-          struct GNUNET_PeerIdentity pid;
-
-          make_peer(cmd->details.reserve_bandwidth.pid,
-                    &pid);
-          cmd->details.reserve_bandwidth.rc
-            = GNUNET_ATS_reserve_bandwidth(perf_ats,
-                                           &pid,
-                                           cmd->details.reserve_bandwidth.amount,
-                                           &reservation_cb,
-                                           cmd);
-          return;
-        }
-
-        case CMD_SLEEP:
-          off++;
-          interpreter_task = GNUNET_SCHEDULER_add_delayed(cmd->details.sleep.delay,
-                                                          &interpreter,
-                                                          NULL);
-          return;
-        } /* end switch */
-    } /* end while(1) */
+                                                   cmd->details.list_addresses.
+                                                   all,
+                                                   &info_cb,
+                                                   cmd);
+        return;
+      }
+
+    case CMD_RESERVE_BANDWIDTH:
+      {
+        struct GNUNET_PeerIdentity pid;
+
+        make_peer (cmd->details.reserve_bandwidth.pid,
+                   &pid);
+        cmd->details.reserve_bandwidth.rc
+          = GNUNET_ATS_reserve_bandwidth (perf_ats,
+                                          &pid,
+                                          cmd->details.reserve_bandwidth.amount,
+                                          &reservation_cb,
+                                          cmd);
+        return;
+      }
+
+    case CMD_SLEEP:
+      off++;
+      interpreter_task = GNUNET_SCHEDULER_add_delayed (cmd->details.sleep.delay,
+                                                       &interpreter,
+                                                       NULL);
+      return;
+    }     /* end switch */
+  }   /* end while(1) */
 }
 
 
@@ -897,59 +905,59 @@ interpreter(void *cls)
  *        0 to signal disconnect
  */
 static void
-address_suggest_cb(void *cls,
-                   const struct GNUNET_PeerIdentity *peer,
-                   const struct GNUNET_HELLO_Address *address,
-                   struct GNUNET_ATS_Session *session,
-                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
+address_suggest_cb (void *cls,
+                    const struct GNUNET_PeerIdentity *peer,
+                    const struct GNUNET_HELLO_Address *address,
+                    struct GNUNET_ATS_Session *session,
+                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
   const char *asc_cls = cls;
   struct AddressSuggestData *asd;
 
-  GNUNET_break(0 == strcmp(asc_cls, "asc-closure"));
+  GNUNET_break (0 == strcmp (asc_cls, "asc-closure"));
   if (NULL == peer)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Connection to ATS died, likely a crash!\n");
-      GNUNET_SCHEDULER_shutdown();
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Connection to ATS died, likely a crash!\n");
+    GNUNET_SCHEDULER_shutdown ();
 #if 0
-      /* This is what we should do if we wanted to continue past
-         the ATS crash. */
-      GNUNET_CONTAINER_multipeermap_iterate(p2asd,
-                                            &free_asd,
-                                            NULL);
-      GNUNET_CONTAINER_multipeermap_iterate(p2aid,
-                                            &free_aid,
-                                            NULL);
+    /* This is what we should do if we wanted to continue past
+       the ATS crash. */
+    GNUNET_CONTAINER_multipeermap_iterate (p2asd,
+                                           &free_asd,
+                                           NULL);
+    GNUNET_CONTAINER_multipeermap_iterate (p2aid,
+                                           &free_aid,
+                                           NULL);
 #endif
-      return;
-    }
+    return;
+  }
 
-  asd = find_address_suggestion(peer);
+  asd = find_address_suggestion (peer);
   if (NULL == asd)
-    {
-      asd = GNUNET_new(struct AddressSuggestData);
-      GNUNET_assert(GNUNET_YES ==
-                    GNUNET_CONTAINER_multipeermap_put(p2asd,
+  {
+    asd = GNUNET_new (struct AddressSuggestData);
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_put (p2asd,
                                                       peer,
                                                       asd,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
-  if ((0 == ntohl(bandwidth_out.value__)) &&
-      (0 == ntohl(bandwidth_in.value__)))
+  }
+  if ((0 == ntohl (bandwidth_out.value__)) &&
+      (0 == ntohl (bandwidth_in.value__)))
     asd->active = GNUNET_NO;
   else
     asd->active = GNUNET_YES;
   asd->bandwidth_out = bandwidth_out;
   asd->bandwidth_in = bandwidth_in;
   asd->session = session;
-  GNUNET_free_non_null(asd->address);
+  GNUNET_free_non_null (asd->address);
   asd->address = NULL;
   if (NULL != address)
-    asd->address = GNUNET_HELLO_address_copy(address);
+    asd->address = GNUNET_HELLO_address_copy (address);
   if (NULL == interpreter_task)
-    run_interpreter();
+    run_interpreter ();
 }
 
 
@@ -967,44 +975,44 @@ address_suggest_cb(void *cls,
  * @param prop performance data for the address
  */
 static void
-address_information_cb(void *cls,
-                       const struct GNUNET_HELLO_Address *address,
-                       int address_active,
-                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
-                       const struct GNUNET_ATS_Properties *prop)
+address_information_cb (void *cls,
+                        const struct GNUNET_HELLO_Address *address,
+                        int address_active,
+                        struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                        struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+                        const struct GNUNET_ATS_Properties *prop)
 {
   const char *aic_cls = cls;
   struct AddressInformationData *aid;
 
-  GNUNET_break(0 == strcmp(aic_cls, "aic-closure"));
+  GNUNET_break (0 == strcmp (aic_cls, "aic-closure"));
   if (NULL == address)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Connection to ATS died, likely a crash!\n");
-      GNUNET_CONTAINER_multipeermap_iterate(p2aid,
-                                            &free_aid,
-                                            NULL);
-      return;
-    }
-
-  aid = find_address_information(address);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Connection to ATS died, likely a crash!\n");
+    GNUNET_CONTAINER_multipeermap_iterate (p2aid,
+                                           &free_aid,
+                                           NULL);
+    return;
+  }
+
+  aid = find_address_information (address);
   if (NULL == aid)
-    {
-      aid = GNUNET_new(struct AddressInformationData);
-      aid->address = GNUNET_HELLO_address_copy(address);
-      GNUNET_assert(GNUNET_YES ==
-                    GNUNET_CONTAINER_multipeermap_put(p2aid,
+  {
+    aid = GNUNET_new (struct AddressInformationData);
+    aid->address = GNUNET_HELLO_address_copy (address);
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_put (p2aid,
                                                       &address->peer,
                                                       aid,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-    }
+  }
   aid->active = address_active;
   aid->bandwidth_out = bandwidth_out;
   aid->bandwidth_in = bandwidth_in;
   aid->properties = *prop;
   if (NULL == interpreter_task)
-    run_interpreter();
+    run_interpreter ();
 }
 
 
@@ -1016,44 +1024,44 @@ address_information_cb(void *cls,
  * @param peer handle to the peer
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
-  p2asd = GNUNET_CONTAINER_multipeermap_create(128,
-                                               GNUNET_NO);
-  p2aid = GNUNET_CONTAINER_multipeermap_create(128,
-                                               GNUNET_NO);
-  GNUNET_SCHEDULER_add_delayed(TIMEOUT,
-                               &end,
-                               NULL);
-
-  sched_ats = GNUNET_ATS_scheduling_init(cfg,
-                                         &address_suggest_cb,
-                                         "asc-closure");
+  p2asd = GNUNET_CONTAINER_multipeermap_create (128,
+                                                GNUNET_NO);
+  p2aid = GNUNET_CONTAINER_multipeermap_create (128,
+                                                GNUNET_NO);
+  GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                &end,
+                                NULL);
+
+  sched_ats = GNUNET_ATS_scheduling_init (cfg,
+                                          &address_suggest_cb,
+                                          "asc-closure");
   if (NULL == sched_ats)
-    {
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  con_ats = GNUNET_ATS_connectivity_init(cfg);
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  con_ats = GNUNET_ATS_connectivity_init (cfg);
   if (NULL == con_ats)
-    {
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  perf_ats = GNUNET_ATS_performance_init(cfg,
-                                         &address_information_cb,
-                                         "aic-closure");
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  perf_ats = GNUNET_ATS_performance_init (cfg,
+                                          &address_information_cb,
+                                          "aic-closure");
   if (NULL == perf_ats)
-    {
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  run_interpreter();
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  run_interpreter ();
 }
 
 
@@ -1067,32 +1075,32 @@ run(void *cls,
  * @return 0 on success
  */
 int
-TEST_ATS_run(int argc,
-             char *argv[],
-             struct Command *cmds,
-             struct GNUNET_TIME_Relative timeout)
+TEST_ATS_run (int argc,
+              char *argv[],
+              struct Command *cmds,
+              struct GNUNET_TIME_Relative timeout)
 {
-  char *test_filename = GNUNET_strdup(argv[0]);
+  char *test_filename = GNUNET_strdup (argv[0]);
   char *sep;
   char *config_file;
   char *underscore;
 
   test_commands = cmds;
   TIMEOUT = timeout;
-  if (NULL != (sep = strstr(test_filename, ".exe")))
+  if (NULL != (sep = strstr (test_filename, ".exe")))
     sep[0] = '\0';
-  underscore = strrchr(test_filename, (int)'_');
-  GNUNET_assert(NULL != underscore);
-  GNUNET_asprintf(&config_file,
-                  "test_ats_api_%s.conf",
-                  underscore + 1);
+  underscore = strrchr (test_filename, (int) '_');
+  GNUNET_assert (NULL != underscore);
+  GNUNET_asprintf (&config_file,
+                   "test_ats_api_%s.conf",
+                   underscore + 1);
   ret = 2;
-  if (0 != GNUNET_TESTING_peer_run("test-ats-api",
-                                   config_file,
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-ats-api",
+                                    config_file,
+                                    &run, NULL))
     ret = 1;
-  GNUNET_free(test_filename);
-  GNUNET_free(config_file);
+  GNUNET_free (test_filename);
+  GNUNET_free (config_file);
   return ret;
 }
 
diff --git a/src/ats/test_ats_lib.h b/src/ats/test_ats_lib.h
index db083d2d7..60b459f79 100644
--- a/src/ats/test_ats_lib.h
+++ b/src/ats/test_ats_lib.h
@@ -33,7 +33,8 @@
 /**
  * Commands for the interpreter.
  */
-enum CommandCode {
+enum CommandCode
+{
   /**
    * End the test (passing).
    */
@@ -128,7 +129,8 @@ enum CommandCode {
 /**
  * Details for the #CMD_ADD_ADDRESS command.
  */
-struct CommandAddAddress {
+struct CommandAddAddress
+{
   /**
    * Number of the peer (used to generate PID).
    */
@@ -169,7 +171,8 @@ struct CommandAddAddress {
 /**
  * Details for the #CMD_DEL_ADDRESS command.
  */
-struct CommandDelAddress {
+struct CommandDelAddress
+{
   /**
    * Label of the corresponding #CMD_ADD_ADDRESS that
    * we are now to remove.
@@ -181,7 +184,8 @@ struct CommandDelAddress {
 /**
  * Details for the #CMD_AWAIT_ADDRESS_SUGGESTION command.
  */
-struct CommandAwaitAddressSuggestion {
+struct CommandAwaitAddressSuggestion
+{
   /**
    * For which peer do we expect a suggestion?
    */
@@ -199,7 +203,8 @@ struct CommandAwaitAddressSuggestion {
 /**
  * Details for the #CMD_AWAIT_DISCONNECT_SUGGESTION command.
  */
-struct CommandAwaitDisconnectSuggestion {
+struct CommandAwaitDisconnectSuggestion
+{
   /**
    * For which peer do we expect the disconnect?
    */
@@ -210,7 +215,8 @@ struct CommandAwaitDisconnectSuggestion {
 /**
  * Details for the #CMD_REQUEST_CONNECTION_START command.
  */
-struct CommandRequestConnectionStart {
+struct CommandRequestConnectionStart
+{
   /**
    * Identity of the peer we would like to connect to.
    */
@@ -227,7 +233,8 @@ struct CommandRequestConnectionStart {
 /**
  * Details for the #CMD_REQUEST_CONNECTION_STOP command.
  */
-struct CommandRequestConnectionStop {
+struct CommandRequestConnectionStop
+{
   /**
    * Label of the corresponding #CMD_REQUEST_CONNECTION_START that
    * we are now stopping.
@@ -239,7 +246,8 @@ struct CommandRequestConnectionStop {
 /**
  * Details for the #CMD_AWAIT_ADDRESS_INFORMATION command.
  */
-struct CommandAwaitAddressInformation {
+struct CommandAwaitAddressInformation
+{
   /**
    * For which address do we expect information?
    * The address is identified by the respective
@@ -259,7 +267,8 @@ struct CommandAwaitAddressInformation {
 /**
  * Details for the #CMD_UPDATE_ADDRESS command.
  */
-struct CommandUpdateAddress {
+struct CommandUpdateAddress
+{
   /**
    * Label of the addresses's add operation.
    */
@@ -275,7 +284,8 @@ struct CommandUpdateAddress {
 /**
  * Details for the #CMD_ADD_SESSION command.
  */
-struct CommandAddSession {
+struct CommandAddSession
+{
   /**
    * Label of the addresses's add operation.
    */
@@ -291,7 +301,8 @@ struct CommandAddSession {
 /**
  * Details for the #CMD_DEL_SESSION command.
  */
-struct CommandDelSession {
+struct CommandDelSession
+{
   /**
    * Label of the addresses's add operation.
    */
@@ -302,7 +313,8 @@ struct CommandDelSession {
 /**
  * Details for the #CMD_CHANGE_PREFERENCE command.
  */
-struct CommandChangePreference {
+struct CommandChangePreference
+{
   /**
    * Identity of the peer we have a preference change towards.
    */
@@ -315,7 +327,8 @@ struct CommandChangePreference {
 /**
  * Details for the #CMD_PROVIDE_FEEDBACK command.
  */
-struct CommandProvideFeedback {
+struct CommandProvideFeedback
+{
   /**
    * Identity of the peer we have a feedback for.
    */
@@ -333,7 +346,8 @@ struct CommandProvideFeedback {
 /**
  * Details for the #CMD_LIST_ADDRESSES command.
  */
-struct CommandListAddresses {
+struct CommandListAddresses
+{
   /**
    * Identity of the peer we want a list for.
    */
@@ -387,7 +401,8 @@ struct CommandListAddresses {
 /**
  * Details for the #CMD_RESERVE_BANDWIDTH command.
  */
-struct CommandReserveBandwidth {
+struct CommandReserveBandwidth
+{
   /**
    * For which peer do we reserve bandwidth?
    */
@@ -417,7 +432,8 @@ struct CommandReserveBandwidth {
 /**
  * Details for the #CMD_SLEEP command.
  */
-struct CommandSleep {
+struct CommandSleep
+{
   /**
    * How long should we wait before running the next command?
    */
@@ -428,7 +444,8 @@ struct CommandSleep {
 /**
  * A command for the test case interpreter.
  */
-struct Command {
+struct Command
+{
   /**
    * Command code to run.
    */
@@ -442,7 +459,8 @@ struct Command {
   /**
    * Additional arguments to commands, if any.
    */
-  union {
+  union
+  {
     struct CommandAddAddress add_address;
 
     struct CommandDelAddress del_address;
@@ -486,9 +504,9 @@ struct Command {
  * @return 0 on success
  */
 int
-TEST_ATS_run(int argc,
-             char *argv[],
-             struct Command *cmds,
-             struct GNUNET_TIME_Relative timeout);
+TEST_ATS_run (int argc,
+              char *argv[],
+              struct Command *cmds,
+              struct GNUNET_TIME_Relative timeout);
 
 #endif
diff --git a/src/ats/test_ats_reservation_api.c b/src/ats/test_ats_reservation_api.c
index f6b0573e1..ff924b3b4 100644
--- a/src/ats/test_ats_reservation_api.c
+++ b/src/ats/test_ats_reservation_api.c
@@ -28,7 +28,7 @@
 /**
  * Global timeout for the testcase.
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
 
 /**
  * Definition of the test as a sequence of commands.
@@ -146,13 +146,13 @@ static struct Command test_commands[] = {
 
 
 int
-main(int argc,
-     char *argv[])
+main (int argc,
+      char *argv[])
 {
-  return TEST_ATS_run(argc,
-                      argv,
-                      test_commands,
-                      TIMEOUT);
+  return TEST_ATS_run (argc,
+                       argv,
+                       test_commands,
+                       TIMEOUT);
 }