1 files changed, 197 insertions, 153 deletions

diff --git a/src/ats/ats_api_scheduling.c b/src/ats/ats_api_scheduling.c
index d2bf06c17..496a18b12 100644
--- a/src/ats/ats_api_scheduling.c
+++ b/src/ats/ats_api_scheduling.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2010,2011 Christian Grothoff (and other contributing authors)
+     (C) 2010-2015 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -164,12 +164,12 @@ struct GNUNET_ATS_SchedulingHandle
   /**
    * Head of network list
    */
-  struct ATS_Network * net_head;
+  struct ATS_Network *net_head;
 
   /**
    * Tail of network list
    */
-  struct ATS_Network * net_tail;
+  struct ATS_Network *net_tail;
 
   /**
    * Array of session objects (we need to translate them to numbers and back
@@ -182,16 +182,15 @@ struct GNUNET_ATS_SchedulingHandle
   /**
    * Task to trigger reconnect.
    */
-  struct GNUNET_SCHEDULER_Task * task;
+  struct GNUNET_SCHEDULER_Task *task;
 
   /**
    * Task retrieving interfaces from the system
    */
-  struct GNUNET_SCHEDULER_Task * interface_task;
-
+  struct GNUNET_SCHEDULER_Task *interface_task;
 
   /**
-   * Size of the session array.
+   * Size of the @e session_array.
    */
   unsigned int session_array_size;
 
@@ -218,7 +217,8 @@ reconnect (struct GNUNET_ATS_SchedulingHandle *sh);
  * @param tc scheduler context
  */
 static void
-reconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect_task (void *cls,
+                const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = cls;
 
@@ -238,9 +238,9 @@ force_reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
   sh->reconnect = GNUNET_NO;
   GNUNET_CLIENT_disconnect (sh->client);
   sh->client = NULL;
-  sh->task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &reconnect_task,
-                                    sh);
+  sh->task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                           &reconnect_task,
+                                           sh);
 }
 
 
@@ -258,23 +258,26 @@ do_transmit (struct GNUNET_ATS_SchedulingHandle *sh);
  * Type of a function to call when we receive a message
  * from the service.
  *
- * @param cls the 'struct GNUNET_ATS_SchedulingHandle'
+ * @param cls the `struct GNUNET_ATS_SchedulingHandle`
  * @param msg message received, NULL on timeout or fatal error
  */
 static void
-process_ats_message (void *cls, const struct GNUNET_MessageHeader *msg);
+process_ats_message (void *cls,
+                     const struct GNUNET_MessageHeader *msg);
 
 
 /**
  * We can now transmit a message to ATS. Do it.
  *
- * @param cls the 'struct GNUNET_ATS_SchedulingHandle'
+ * @param cls the `struct GNUNET_ATS_SchedulingHandle`
  * @param size number of bytes we can transmit to ATS
  * @param buf where to copy the messages
- * @return number of bytes copied into buf
+ * @return number of bytes copied into @a buf
  */
 static size_t
-transmit_message_to_ats (void *cls, size_t size, void *buf)
+transmit_message_to_ats (void *cls,
+                         size_t size,
+                         void *buf)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = cls;
   struct PendingMessage *p;
@@ -282,7 +285,7 @@ transmit_message_to_ats (void *cls, size_t size, void *buf)
   char *cbuf;
 
   sh->th = NULL;
-  if ((size == 0) || (buf == NULL))
+  if ((0 == size) || (NULL == buf))
   {
     force_reconnect (sh);
     return 0;
@@ -291,10 +294,14 @@ transmit_message_to_ats (void *cls, size_t size, void *buf)
   cbuf = buf;
   while ((NULL != (p = sh->pending_head)) && (p->size <= size))
   {
-    memcpy (&cbuf[ret], &p[1], p->size);
+    memcpy (&cbuf[ret],
+            &p[1],
+            p->size);
     ret += p->size;
     size -= p->size;
-    GNUNET_CONTAINER_DLL_remove (sh->pending_head, sh->pending_tail, p);
+    GNUNET_CONTAINER_DLL_remove (sh->pending_head,
+                                 sh->pending_tail,
+                                 p);
     GNUNET_free (p);
   }
   do_transmit (sh);
@@ -336,10 +343,10 @@ do_transmit (struct GNUNET_ATS_SchedulingHandle *sh)
  * @return the session object (or NULL)
  */
 static struct Session *
-find_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
+find_session (struct GNUNET_ATS_SchedulingHandle *sh,
+              uint32_t session_id,
               const struct GNUNET_PeerIdentity *peer)
 {
-
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-scheduling-api",
               "Find session %u from peer %s in %p\n",
               (unsigned int) session_id, GNUNET_i2s (peer), sh);
@@ -396,16 +403,19 @@ find_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
  * @return the session id
  */
 static uint32_t
-find_empty_session_slot (struct GNUNET_ATS_SchedulingHandle *sh, struct Session *session,
-                const struct GNUNET_PeerIdentity *peer)
+find_empty_session_slot (struct GNUNET_ATS_SchedulingHandle *sh,
+                         struct Session *session,
+                         const struct GNUNET_PeerIdentity *peer)
 {
   unsigned int i;
   unsigned int f;
 
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-scheduling-api",
-              "Get session ID for session %p from peer %s in %p\n", session,
-              GNUNET_i2s (peer), sh);
-
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "ats-scheduling-api",
+                   "Get session ID for session %p from peer %s in %p\n",
+                   session,
+                   GNUNET_i2s (peer),
+                   sh);
   if (NULL == session)
     return NOT_FOUND;
   f = 0;
@@ -442,8 +452,9 @@ find_empty_session_slot (struct GNUNET_ATS_SchedulingHandle *sh, struct Session
  * @return the session id or NOT_FOUND for error
  */
 static uint32_t
-find_session_id (struct GNUNET_ATS_SchedulingHandle *sh, struct Session *session,
-                const struct GNUNET_PeerIdentity *peer)
+find_session_id (struct GNUNET_ATS_SchedulingHandle *sh,
+                 struct Session *session,
+                 const struct GNUNET_PeerIdentity *peer)
 {
   unsigned int i;
   char * p2;
@@ -484,15 +495,16 @@ find_session_id (struct GNUNET_ATS_SchedulingHandle *sh, struct Session *session
  * @param peer peer the session belongs to
  */
 static void
-remove_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
+remove_session (struct GNUNET_ATS_SchedulingHandle *sh,
+                uint32_t session_id,
                 const struct GNUNET_PeerIdentity *peer)
 {
-  GNUNET_assert (peer != NULL);
-  GNUNET_assert (sh != NULL);
-
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-scheduling-api",
-              "Release sessionID %u from peer %s in %p\n",
-              (unsigned int) session_id, GNUNET_i2s (peer), sh);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "ats-scheduling-api",
+                   "Release sessionID %u from peer %s in %p\n",
+                   (unsigned int) session_id,
+                   GNUNET_i2s (peer),
+                   sh);
 
   if (0 == session_id)
     return;
@@ -508,7 +520,6 @@ remove_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
               GNUNET_i2s (peer),
               session_id);
   sh->session_array[session_id].session = NULL;
-
 }
 
 
@@ -521,7 +532,8 @@ remove_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
  * @param peer peer the session belongs to
  */
 static void
-release_session (struct GNUNET_ATS_SchedulingHandle *sh, uint32_t session_id,
+release_session (struct GNUNET_ATS_SchedulingHandle *sh,
+                 uint32_t session_id,
                  const struct GNUNET_PeerIdentity *peer)
 {
 
@@ -565,11 +577,12 @@ process_release_message (struct GNUNET_ATS_SchedulingHandle *sh,
  * Type of a function to call when we receive a message
  * from the service.
  *
- * @param cls the 'struct GNUNET_ATS_SchedulingHandle'
+ * @param cls the `struct GNUNET_ATS_SchedulingHandle`
  * @param msg message received, NULL on timeout or fatal error
  */
 static void
-process_ats_message (void *cls, const struct GNUNET_MessageHeader *msg)
+process_ats_message (void *cls,
+                     const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = cls;
   const struct AddressSuggestionMessage *m;
@@ -688,9 +701,11 @@ reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
   GNUNET_assert (NULL == sh->client);
   sh->client = GNUNET_CLIENT_connect ("ats", sh->cfg);
   GNUNET_assert (NULL != sh->client);
-  GNUNET_CLIENT_receive (sh->client, &process_ats_message, sh,
-                           GNUNET_TIME_UNIT_FOREVER_REL);
-  if ((NULL == (p = sh->pending_head)) || (GNUNET_YES != p->is_init))
+  GNUNET_CLIENT_receive (sh->client,
+                         &process_ats_message, sh,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+  if ( (NULL == (p = sh->pending_head)) ||
+       (GNUNET_YES != p->is_init) )
   {
     p = GNUNET_malloc (sizeof (struct PendingMessage) +
                        sizeof (struct ClientStartMessage));
@@ -700,39 +715,44 @@ reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
     init->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_START);
     init->header.size = htons (sizeof (struct ClientStartMessage));
     init->start_flag = htonl (START_FLAG_SCHEDULING);
-    GNUNET_CONTAINER_DLL_insert (sh->pending_head, sh->pending_tail, p);
+    GNUNET_CONTAINER_DLL_insert (sh->pending_head,
+                                 sh->pending_tail,
+                                 p);
   }
   do_transmit (sh);
 }
 
 
 /**
- * delete the current network list
+ * Delete the current network list.
+ *
+ * @param sh scheduling handle to clean up
  */
 static void
 delete_networks (struct GNUNET_ATS_SchedulingHandle *sh)
 {
-  struct ATS_Network * cur = sh->net_head;
-  while (cur != NULL)
+  struct ATS_Network *cur;
+
+  while (NULL != (cur = sh->net_head))
   {
-    GNUNET_CONTAINER_DLL_remove(sh->net_head, sh->net_tail, cur);
+    GNUNET_CONTAINER_DLL_remove (sh->net_head,
+                                 sh->net_tail,
+                                 cur);
     GNUNET_free (cur);
-    cur = sh->net_head;
   }
 }
 
 
 static int
-interface_proc (void *cls, const char *name,
+interface_proc (void *cls,
+                const char *name,
                 int isDefault,
-                const struct sockaddr *
-                addr,
-                const struct sockaddr *
-                broadcast_addr,
-                const struct sockaddr *
-                netmask, socklen_t addrlen)
+                const struct sockaddr *addr,
+                const struct sockaddr *broadcast_addr,
+                const struct sockaddr *netmask,
+                socklen_t addrlen)
 {
-  struct GNUNET_ATS_SchedulingHandle * sh = cls;
+  struct GNUNET_ATS_SchedulingHandle *sh = cls;
   /* Calculate network */
   struct ATS_Network *net = NULL;
 
@@ -822,19 +842,23 @@ interface_proc (void *cls, const char *name,
 
 
 /**
- * Periodically get list of addresses
+ * Periodically get list of network addresses from our interfaces.
+ *
  * @param cls closure
  * @param tc Task context
  */
 static void
-get_addresses (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+get_addresses (void *cls,
+               const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct GNUNET_ATS_SchedulingHandle * sh = cls;
+  struct GNUNET_ATS_SchedulingHandle *sh = cls;
+
   sh->interface_task = NULL;
   delete_networks (sh);
-  GNUNET_OS_network_interfaces_list(interface_proc, sh);
+  GNUNET_OS_network_interfaces_list (&interface_proc,
+                                     sh);
   sh->interface_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_PROCESSING_INTERVALL,
-                                                     get_addresses,
+                                                     &get_addresses,
                                                      sh);
 }
 
@@ -913,37 +937,41 @@ GNUNET_ATS_print_property_type (enum GNUNET_ATS_Property type)
  * @param sh the scheduling handle
  * @param addr address
  * @param addrlen address length
- * @return location as GNUNET_ATS_Information
+ * @return type of the network the address belongs to
  */
-struct GNUNET_ATS_Information
-GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle * sh, const struct sockaddr * addr, socklen_t addrlen)
+enum GNUNET_ATS_Network_Type
+GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle *sh,
+                             const struct sockaddr *addr,
+                             socklen_t addrlen)
 {
-  GNUNET_assert (sh != NULL);
-  struct ATS_Network * cur = sh->net_head;
-
-  int type = GNUNET_ATS_NET_UNSPECIFIED;
-  struct GNUNET_ATS_Information ats;
+  struct ATS_Network *cur = sh->net_head;
+  enum GNUNET_ATS_NetworkType type = GNUNET_ATS_NET_UNSPECIFIED;
 
-  if  (addr->sa_family == AF_UNIX)
-  {
-    type = GNUNET_ATS_NET_LOOPBACK;
-  }
+  switch (addr->sa_family)
+    {
+    case AF_UNIX:
+      type = GNUNET_ATS_NET_LOOPBACK;
+      break;
+    case AF_INET:
+      {
+        const struct sockaddr_in *a4 = (const struct sockaddr_in *) addr;
 
-  /* IPv4 loopback check */
-  if  (addr->sa_family == AF_INET)
-  {
-    struct sockaddr_in * a4 = (struct sockaddr_in *) addr;
+        if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl (0x7f000000))
+          type = GNUNET_ATS_NET_LOOPBACK;
+        break;
+      }
+    case AF_INET6:
+      {
+        const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *) addr;
 
-    if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl (0x7f000000))
-      type = GNUNET_ATS_NET_LOOPBACK;
-  }
-  /* IPv6 loopback check */
-  if  (addr->sa_family == AF_INET6)
-  {
-    struct sockaddr_in6 * a6 = (struct sockaddr_in6 *) addr;
-    if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr))
-      type = GNUNET_ATS_NET_LOOPBACK;
-  }
+        if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr))
+          type = GNUNET_ATS_NET_LOOPBACK;
+        break;
+      }
+    default:
+      GNUNET_break (0);
+      break;
+   }
 
   /* Check local networks */
   while ((cur != NULL) && (type == GNUNET_ATS_NET_UNSPECIFIED))
@@ -953,7 +981,6 @@ GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle * sh, const stru
       cur = cur->next;
       continue;
     }
-
     if (addr->sa_family == AF_INET)
     {
       struct sockaddr_in * a4 = (struct sockaddr_in *) addr;
@@ -987,14 +1014,13 @@ GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle * sh, const stru
   /* no local network found for this address, default: WAN */
   if (type == GNUNET_ATS_NET_UNSPECIFIED)
     type = GNUNET_ATS_NET_WAN;
-  ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
-  ats.value = htonl (type);
-
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-scheduling-api",
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "ats-scheduling-api",
                    "`%s' is in network `%s'\n",
-                   GNUNET_a2s ((const struct sockaddr *) addr, addrlen),
-                   GNUNET_ATS_print_network_type(type));
-  return ats;
+                   GNUNET_a2s (addr,
+                               addrlen),
+                   GNUNET_ATS_print_network_type (type));
+  return type;
 }
 
 
@@ -1003,7 +1029,7 @@ GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle * sh, const stru
  *
  * @param cfg configuration to use
  * @param suggest_cb notification to call whenever the suggestation changed
- * @param suggest_cb_cls closure for 'suggest_cb'
+ * @param suggest_cb_cls closure for @a suggest_cb
  * @return ats context
  */
 struct GNUNET_ATS_SchedulingHandle *
@@ -1017,11 +1043,14 @@ GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
   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);
-  GNUNET_OS_network_interfaces_list(interface_proc, sh);
+  GNUNET_array_grow (sh->session_array,
+                     sh->session_array_size,
+                     4);
+  GNUNET_OS_network_interfaces_list (&interface_proc,
+                                     sh);
   sh->interface_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_PROCESSING_INTERVALL,
-      get_addresses,
-      sh);
+                                                     &get_addresses,
+                                                     sh);
   reconnect (sh);
   return sh;
 }
@@ -1037,10 +1066,12 @@ GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh)
 {
   struct PendingMessage *p;
   struct GNUNET_ATS_SuggestHandle *cur;
-  struct GNUNET_ATS_SuggestHandle *next;
+
   while (NULL != (p = sh->pending_head))
   {
-    GNUNET_CONTAINER_DLL_remove (sh->pending_head, sh->pending_tail, p);
+    GNUNET_CONTAINER_DLL_remove (sh->pending_head,
+                                 sh->pending_tail,
+                                 p);
     GNUNET_free (p);
   }
   if (NULL != sh->client)
@@ -1053,26 +1084,26 @@ GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh)
     GNUNET_SCHEDULER_cancel (sh->task);
     sh->task = NULL;
   }
-
-  next = sh->sug_head;
-  while (NULL != (cur = next))
+  while (NULL != (cur = sh->sug_head))
   {
-                next = cur->next;
-                GNUNET_CONTAINER_DLL_remove (sh->sug_head, sh->sug_tail, cur);
-                GNUNET_free (cur);
+    GNUNET_CONTAINER_DLL_remove (sh->sug_head,
+                                 sh->sug_tail,
+                                 cur);
+    GNUNET_free (cur);
   }
-
   delete_networks (sh);
-  if (sh->interface_task != NULL)
+  if (NULL != sh->interface_task)
   {
-    GNUNET_SCHEDULER_cancel(sh->interface_task);
+    GNUNET_SCHEDULER_cancel (sh->interface_task);
     sh->interface_task = NULL;
   }
-  GNUNET_array_grow (sh->session_array, sh->session_array_size, 0);
+  GNUNET_array_grow (sh->session_array,
+                     sh->session_array_size,
+                     0);
   GNUNET_free (sh);
-  sh = NULL;
 }
 
+
 /**
  * We would like to reset the address suggestion block time for this
  * peer
@@ -1096,7 +1127,9 @@ GNUNET_ATS_reset_backoff (struct GNUNET_ATS_SchedulingHandle *sh,
   m->header.size = htons (sizeof (struct ResetBackoffMessage));
   m->reserved = htonl (0);
   m->peer = *peer;
-  GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head, sh->pending_tail, p);
+  GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head,
+                                    sh->pending_tail,
+                                    p);
   do_transmit (sh);
 }
 
@@ -1157,18 +1190,17 @@ GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
   struct GNUNET_ATS_SuggestHandle *s;
 
   for (s = sh->sug_head; NULL != s; s = s->next)
-        if (0 == memcmp(peer, &s->id, sizeof (s->id)))
-                break;
+    if (0 == memcmp (peer, &s->id, sizeof (s->id)))
+      break;
   if (NULL == s)
   {
-        GNUNET_break (0);
-        return;
-  }
-  else
-  {
-        GNUNET_CONTAINER_DLL_remove (sh->sug_head, sh->sug_tail, s);
-        GNUNET_free (s);
+    GNUNET_break (0);
+    return;
   }
+  GNUNET_CONTAINER_DLL_remove (sh->sug_head,
+                               sh->sug_tail,
+                               s);
+  GNUNET_free (s);
 
   p = GNUNET_malloc (sizeof (struct PendingMessage) +
                      sizeof (struct RequestAddressMessage));
@@ -1179,7 +1211,9 @@ GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
   m->header.size = htons (sizeof (struct RequestAddressMessage));
   m->reserved = htonl (0);
   m->peer = *peer;
-  GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head, sh->pending_tail, p);
+  GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head,
+                                    sh->pending_tail,
+                                    p);
   do_transmit (sh);
 }
 
@@ -1190,26 +1224,23 @@ GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
  * @param sh the scheduling handle
  * @param address the address
  * @param session the session
- * @return GNUNET_YES or GNUNET_NO
+ * @return #GNUNET_YES or #GNUNET_NO
  */
 int
 GNUNET_ATS_session_known (struct GNUNET_ATS_SchedulingHandle *sh,
-                                                                                        const struct GNUNET_HELLO_Address *address,
-                                                                                        struct Session *session)
+                          const struct GNUNET_HELLO_Address *address,
+                          struct Session *session)
 {
-        int s;
-  if (NULL != session)
-  {
-    if (NOT_FOUND != (s = find_session_id (sh, session, &address->peer)))
-    {
-      /* Existing */
-      return GNUNET_YES;
-    }
+  if (NULL == session)
     return GNUNET_NO;
-  }
+  if (NOT_FOUND != find_session_id (sh,
+                                    session,
+                                    &address->peer))
+    return GNUNET_YES;  /* Exists */
   return GNUNET_NO;
 }
 
+
 /**
  * We have a new address ATS should know. Addresses have to be added with this
  * function before they can be: updated, set in use and destroyed
@@ -1218,8 +1249,8 @@ GNUNET_ATS_session_known (struct GNUNET_ATS_SchedulingHandle *sh,
  * @param address the address
  * @param session session handle, can be NULL
  * @param ats performance data for the address
- * @param ats_count number of performance records in 'ats'
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @param ats_count number of performance records in @a ats
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
 GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
@@ -1237,16 +1268,18 @@ GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
   size_t msize;
   uint32_t s = 0;
 
-  if (address == NULL)
+  if (NULL == address)
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
 
-  namelen = (address->transport_name == NULL) ? 0 : strlen (address->transport_name) + 1;
+  namelen = (NULL == address->transport_name)
+    ? 0
+    : strlen (address->transport_name) + 1;
 
   msize = sizeof (struct AddressUpdateMessage) + address->address_length +
-      ats_count * sizeof (struct GNUNET_ATS_Information) + namelen;
+    ats_count * sizeof (struct GNUNET_ATS_Information) + namelen;
   if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
       (address->address_length >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
       (namelen >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
@@ -1264,7 +1297,9 @@ GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
       /* Already existing, nothing todo */
       return GNUNET_SYSERR;
     }
-    s = find_empty_session_slot (sh, session, &address->peer);
+    s = find_empty_session_slot (sh,
+                                 session,
+                                 &address->peer);
     GNUNET_break (NOT_FOUND != s);
   }
 
@@ -1284,18 +1319,23 @@ GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Adding address for peer `%s', plugin `%s', session %p id %u\n",
               GNUNET_i2s (&address->peer),
-              address->transport_name, session, s);
+              address->transport_name,
+              session,
+              s);
 
   am = (struct GNUNET_ATS_Information *) &m[1];
   memcpy (am, ats, ats_count * sizeof (struct GNUNET_ATS_Information));
   pm = (char *) &am[ats_count];
   memcpy (pm, address->address, address->address_length);
   if (NULL != address->transport_name)
-        memcpy (&pm[address->address_length], address->transport_name, namelen);
-  GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head, sh->pending_tail, p);
+    memcpy (&pm[address->address_length],
+            address->transport_name,
+            namelen);
+  GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head,
+                                    sh->pending_tail,
+                                    p);
   do_transmit (sh);
   return GNUNET_OK;
-
 }
 
 
@@ -1380,10 +1420,14 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Updating address for peer `%s', plugin `%s', session %p id %u\n",
               GNUNET_i2s (&address->peer),
-              address->transport_name, session, s);
+              address->transport_name,
+              session,
+              s);
 
   am = (struct GNUNET_ATS_Information *) &m[1];
-  memcpy (am, ats, ats_count * sizeof (struct GNUNET_ATS_Information));
+  memcpy (am,
+          ats,
+          ats_count * sizeof (struct GNUNET_ATS_Information));
   pm = (char *) &am[ats_count];
   memcpy (pm, address->address, address->address_length);
   memcpy (&pm[address->address_length], address->transport_name, namelen);
@@ -1405,7 +1449,8 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
 void
 GNUNET_ATS_address_in_use (struct GNUNET_ATS_SchedulingHandle *sh,
                            const struct GNUNET_HELLO_Address *address,
-                           struct Session *session, int in_use)
+                           struct Session *session,
+                           int in_use)
 {
   struct PendingMessage *p;
   struct AddressUseMessage *m;
@@ -1470,7 +1515,6 @@ GNUNET_ATS_address_in_use (struct GNUNET_ATS_SchedulingHandle *sh,
   memcpy (&pm[address->address_length], address->transport_name, namelen);
   GNUNET_CONTAINER_DLL_insert_tail (sh->pending_head, sh->pending_tail, p);
   do_transmit (sh);
-  return;
 }
 
 
@@ -1494,9 +1538,9 @@ GNUNET_ATS_address_destroyed (struct GNUNET_ATS_SchedulingHandle *sh,
   char *pm;
   size_t namelen;
   size_t msize;
-  uint32_t s = 0;
+  uint32_t s;
 
-  if (address == NULL)
+  if (NULL == address)
   {
     GNUNET_break (0);
     return;