indentation

78 files changed, 1448 insertions, 1793 deletions

diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c
index d138ffba1..95ff4bfff 100644
--- a/src/util/bandwidth.c
+++ b/src/util/bandwidth.c
@@ -41,8 +41,7 @@ GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second)
   struct GNUNET_BANDWIDTH_Value32NBO ret;
 
 #if DEBUG_BANDWIDTH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Initializing bandwidth of %u Bps\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing bandwidth of %u Bps\n",
               (unsigned int) bytes_per_second);
 #endif
   ret.value__ = htonl (bytes_per_second);
@@ -61,8 +60,9 @@ struct GNUNET_BANDWIDTH_Value32NBO
 GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1,
                             struct GNUNET_BANDWIDTH_Value32NBO b2)
 {
-  return GNUNET_BANDWIDTH_value_init (GNUNET_MIN (ntohl (b1.value__),
-                                                  ntohl (b2.value__)));
+  return
+      GNUNET_BANDWIDTH_value_init (GNUNET_MIN
+                                   (ntohl (b1.value__), ntohl (b2.value__)));
 }
 
 
@@ -152,8 +152,7 @@ GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av,
   av->max_carry_s__ = max_carry_s;
 #if DEBUG_BANDWIDTH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Tracker %p initialized with %u Bps and max carry %u\n",
-              av,
+              "Tracker %p initialized with %u Bps and max carry %u\n", av,
               (unsigned int) av->available_bytes_per_s__,
               (unsigned int) max_carry_s);
 #endif
@@ -196,8 +195,7 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
 #if DEBUG_BANDWIDTH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Tracker %p  updated, have %u Bps, last update was %llu ms ago\n",
-              av,
-              (unsigned int) av->available_bytes_per_s__,
+              av, (unsigned int) av->available_bytes_per_s__,
               (unsigned long long) delta_time);
 #endif
 
@@ -222,8 +220,8 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
   int64_t nc;
 
 #if DEBUG_BANDWIDTH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Tracker %p consumes %d bytes\n", av, (int) size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p consumes %d bytes\n", av,
+              (int) size);
 #endif
   if (size > 0)
   {
@@ -239,8 +237,8 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
     {
 #if DEBUG_BANDWIDTH
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Tracker %p consumption %llu bytes above limit\n",
-                  av, (unsigned long long) av->consumption_since_last_update__);
+                  "Tracker %p consumption %llu bytes above limit\n", av,
+                  (unsigned long long) av->consumption_since_last_update__);
 #endif
       return GNUNET_YES;
     }
@@ -282,8 +280,8 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av,
   {
 #if DEBUG_BANDWIDTH
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Tracker %p delay for %u bytes is zero\n",
-                av, (unsigned int) size);
+                "Tracker %p delay for %u bytes is zero\n", av,
+                (unsigned int) size);
 #endif
     return GNUNET_TIME_UNIT_ZERO;
   }
@@ -291,8 +289,8 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av,
       1000LL * bytes_needed / (unsigned long long) av->available_bytes_per_s__;
 #if DEBUG_BANDWIDTH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Tracker %p delay for %u bytes is %llu ms\n",
-              av, (unsigned int) size, (unsigned long long) ret.rel_value);
+              "Tracker %p delay for %u bytes is %llu ms\n", av,
+              (unsigned int) size, (unsigned long long) ret.rel_value);
 #endif
   return ret;
 }
@@ -314,14 +312,15 @@ GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker * av)
 
   update_tracker (av);
   bps = GNUNET_BANDWIDTH_value_init (av->available_bytes_per_s__);
-  avail = GNUNET_BANDWIDTH_value_get_available_until (bps,
-                                                      GNUNET_TIME_absolute_get_duration
-                                                      (av->last_update__));
+  avail =
+      GNUNET_BANDWIDTH_value_get_available_until (bps,
+                                                  GNUNET_TIME_absolute_get_duration
+                                                  (av->last_update__));
   used = av->consumption_since_last_update__;
 #if DEBUG_BANDWIDTH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Tracker %p  available bandwidth is %lld bytes\n",
-              av, (long long) (int64_t) (avail - used));
+              "Tracker %p  available bandwidth is %lld bytes\n", av,
+              (long long) (int64_t) (avail - used));
 #endif
   return (int64_t) (avail - used);
 }
@@ -344,8 +343,8 @@ GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av,
   new_limit = ntohl (bytes_per_second_limit.value__);
 #if DEBUG_BANDWIDTH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Tracker %p bandwidth changed to %u Bps\n",
-              av, (unsigned int) new_limit);
+              "Tracker %p bandwidth changed to %u Bps\n", av,
+              (unsigned int) new_limit);
 #endif
   update_tracker (av);
   old_limit = av->available_bytes_per_s__;
diff --git a/src/util/bio.c b/src/util/bio.c
index b29d75eb9..404b7aa3b 100644
--- a/src/util/bio.c
+++ b/src/util/bio.c
@@ -101,8 +101,8 @@ GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
-                 const char *what, void *result, size_t len)
+GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h, const char *what,
+                 void *result, size_t len)
 {
   char *dst = result;
   size_t min;
@@ -131,14 +131,14 @@ GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
     ret = GNUNET_DISK_file_read (h->fd, h->buffer, h->size);
     if (ret == -1)
     {
-      GNUNET_asprintf (&h->emsg,
-                       _("Error reading `%s': %s"), what, STRERROR (errno));
+      GNUNET_asprintf (&h->emsg, _("Error reading `%s': %s"), what,
+                       STRERROR (errno));
       return GNUNET_SYSERR;
     }
     if (ret == 0)
     {
-      GNUNET_asprintf (&h->emsg,
-                       _("Error reading `%s': %s"), what, _("End of file"));
+      GNUNET_asprintf (&h->emsg, _("Error reading `%s': %s"), what,
+                       _("End of file"));
       return GNUNET_SYSERR;
     }
     h->pos = 0;
@@ -160,8 +160,8 @@ GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read_fn (struct GNUNET_BIO_ReadHandle *h,
-                    const char *file, int line, void *result, size_t len)
+GNUNET_BIO_read_fn (struct GNUNET_BIO_ReadHandle *h, const char *file, int line,
+                    void *result, size_t len)
 {
   char what[1024];
 
@@ -181,8 +181,8 @@ GNUNET_BIO_read_fn (struct GNUNET_BIO_ReadHandle *h,
  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
-                        const char *what, char **result, size_t maxLen)
+GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h, const char *what,
+                        char **result, size_t maxLen)
 {
   char *buf;
   uint32_t big;
@@ -200,8 +200,7 @@ GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
   }
   if (big > maxLen)
   {
-    GNUNET_asprintf (&h->emsg,
-                     _("String `%s' longer than allowed (%u > %u)"),
+    GNUNET_asprintf (&h->emsg, _("String `%s' longer than allowed (%u > %u)"),
                      what, big, maxLen);
     return GNUNET_SYSERR;
   }
@@ -229,8 +228,7 @@ GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
-                           const char *what,
+GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h, const char *what,
                            struct GNUNET_CONTAINER_MetaData **result)
 {
   uint32_t size;
@@ -280,8 +278,8 @@ GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h,
-                         const char *file, int line, int32_t * i)
+GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h, const char *file,
+                         int line, int32_t * i)
 {
   int32_t big;
 
@@ -302,8 +300,8 @@ GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h,
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_read_int64__ (struct GNUNET_BIO_ReadHandle *h,
-                         const char *file, int line, int64_t * i)
+GNUNET_BIO_read_int64__ (struct GNUNET_BIO_ReadHandle *h, const char *file,
+                         int line, int64_t * i)
 {
   int64_t big;
 
@@ -339,9 +337,8 @@ GNUNET_BIO_write_open (const char *fn)
   struct GNUNET_BIO_WriteHandle *h;
 
   fd = GNUNET_DISK_file_open (fn,
-                              GNUNET_DISK_OPEN_WRITE |
-                              GNUNET_DISK_OPEN_TRUNCATE |
-                              GNUNET_DISK_OPEN_CREATE,
+                              GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE
+                              | GNUNET_DISK_OPEN_CREATE,
                               GNUNET_DISK_PERM_USER_READ |
                               GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == fd)
@@ -394,8 +391,8 @@ GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h)
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h,
-                  const void *buffer, size_t n)
+GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h, const void *buffer,
+                  size_t n)
 {
   const char *src = buffer;
   size_t min;
@@ -470,10 +467,9 @@ GNUNET_BIO_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
   if (m == NULL)
     return GNUNET_BIO_write_int32 (h, 0);
   buf = NULL;
-  size = GNUNET_CONTAINER_meta_data_serialize (m,
-                                               &buf,
-                                               MAX_META_DATA,
-                                               GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+  size =
+      GNUNET_CONTAINER_meta_data_serialize (m, &buf, MAX_META_DATA,
+                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (size == -1)
   {
     GNUNET_free (buf);
diff --git a/src/util/client.c b/src/util/client.c
index 032a6c5e4..59cd26ad1 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -293,15 +293,11 @@ do_connect (const char *service_name,
 #endif
 
   if ((GNUNET_OK !=
-       GNUNET_CONFIGURATION_get_value_number (cfg,
-                                              service_name,
-                                              "PORT",
-                                              &port)) ||
-      (port > 65535) ||
+       GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "PORT", &port))
+      || (port > 65535) ||
       (GNUNET_OK !=
-       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                              service_name,
-                                              "HOSTNAME", &hostname)))
+       GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "HOSTNAME",
+                                              &hostname)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _
@@ -325,13 +321,12 @@ do_connect (const char *service_name,
       /* try UNIX */
       unixpath = NULL;
       if ((GNUNET_OK ==
-           GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                  service_name,
-                                                  "UNIXPATH", &unixpath)) &&
+           GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "UNIXPATH",
+                                                  &unixpath)) &&
           (0 < strlen (unixpath)))
       {
-        sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg,
-                                                                  unixpath);
+        sock =
+            GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, unixpath);
         if (sock != NULL)
         {
           GNUNET_free (unixpath);
@@ -457,8 +452,8 @@ check_complete (struct GNUNET_CLIENT_Connection *conn)
 {
   if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) &&
       (conn->received_pos >=
-       ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)->
-              size)))
+       ntohs (((const struct GNUNET_MessageHeader *) conn->
+               received_buf)->size)))
     conn->msg_complete = GNUNET_YES;
 }
 
@@ -476,9 +471,7 @@ check_complete (struct GNUNET_CLIENT_Connection *conn)
  * @param errCode value of errno (on errors receiving)
  */
 static void
-receive_helper (void *cls,
-                const void *buf,
-                size_t available,
+receive_helper (void *cls, const void *buf, size_t available,
                 const struct sockaddr *addr, socklen_t addrlen, int errCode)
 {
   struct GNUNET_CLIENT_Connection *conn = cls;
@@ -512,8 +505,8 @@ receive_helper (void *cls,
 
   /* slow path: append to array */
   if (conn->received_size < conn->received_pos + available)
-    GNUNET_array_grow (conn->received_buf,
-                       conn->received_size, conn->received_pos + available);
+    GNUNET_array_grow (conn->received_buf, conn->received_size,
+                       conn->received_pos + available);
   memcpy (&conn->received_buf[conn->received_pos], buf, available);
   conn->received_pos += available;
   check_complete (conn);
@@ -527,8 +520,7 @@ receive_helper (void *cls,
     return;
   }
   /* back to receive -- either for more data or to call callback! */
-  GNUNET_CLIENT_receive (conn,
-                         conn->receiver_handler,
+  GNUNET_CLIENT_receive (conn, conn->receiver_handler,
                          conn->receiver_handler_cls, remaining);
 }
 
@@ -553,15 +545,15 @@ receive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 #if DEBUG_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received message of type %u and size %u\n",
-              ntohs (cmsg->type), msize);
+              "Received message of type %u and size %u\n", ntohs (cmsg->type),
+              msize);
 #endif
   sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_assert (GNUNET_YES == sock->msg_complete);
   GNUNET_assert (sock->received_pos >= msize);
   memcpy (msg, cmsg, msize);
-  memmove (sock->received_buf,
-           &sock->received_buf[msize], sock->received_pos - msize);
+  memmove (sock->received_buf, &sock->received_buf[msize],
+           sock->received_pos - msize);
   sock->received_pos -= msize;
   sock->msg_complete = GNUNET_NO;
   sock->receiver_handler = NULL;
@@ -581,8 +573,8 @@ receive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 void
 GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
-                       GNUNET_CLIENT_MessageHandler handler,
-                       void *handler_cls, struct GNUNET_TIME_Relative timeout)
+                       GNUNET_CLIENT_MessageHandler handler, void *handler_cls,
+                       struct GNUNET_TIME_Relative timeout)
 {
   if (sock->sock == NULL)
   {
@@ -607,8 +599,7 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
 #if DEBUG_CLIENT
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "calling GNUNET_CONNECTION_receive\n");
 #endif
-    GNUNET_CONNECTION_receive (sock->sock,
-                               GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+    GNUNET_CONNECTION_receive (sock->sock, GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
                                timeout, &receive_helper, sock);
   }
 }
@@ -620,8 +611,8 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
 static void
 service_test_error (GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  GNUNET_SCHEDULER_add_continuation (task,
-                                     task_cls, GNUNET_SCHEDULER_REASON_TIMEOUT);
+  GNUNET_SCHEDULER_add_continuation (task, task_cls,
+                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
 }
 
 
@@ -645,8 +636,7 @@ confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Received confirmation that service is running.\n");
 #endif
-    GNUNET_SCHEDULER_add_continuation (conn->test_cb,
-                                       conn->test_cb_cls,
+    GNUNET_SCHEDULER_add_continuation (conn->test_cb, conn->test_cb_cls,
                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
   }
   else
@@ -688,11 +678,9 @@ write_test (void *cls, size_t size, void *buf)
   msg = (struct GNUNET_MessageHeader *) buf;
   msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
-  GNUNET_CLIENT_receive (conn,
-                         &confirm_handler,
-                         conn,
-                         GNUNET_TIME_absolute_get_remaining
-                         (conn->test_deadline));
+  GNUNET_CLIENT_receive (conn, &confirm_handler, conn,
+                         GNUNET_TIME_absolute_get_remaining (conn->
+                                                             test_deadline));
   return sizeof (struct GNUNET_MessageHeader);
 }
 
@@ -722,8 +710,8 @@ GNUNET_CLIENT_service_test (const char *service,
   struct GNUNET_CLIENT_Connection *conn;
 
 #if DEBUG_CLIENT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Testing if service `%s' is running.\n", service);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing if service `%s' is running.\n",
+              service);
 #endif
 #ifdef AF_UNIX
   {
@@ -761,15 +749,13 @@ GNUNET_CLIENT_service_test (const char *service,
           s_un.sun_len = (u_char) slen;
 #endif
           if (GNUNET_OK !=
-              GNUNET_NETWORK_socket_bind (sock,
-                                          (const struct sockaddr *) &s_un,
+              GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) &s_un,
                                           slen))
           {
             /* failed to bind => service must be running */
             GNUNET_free (unixpath);
             (void) GNUNET_NETWORK_socket_close (sock);
-            GNUNET_SCHEDULER_add_continuation (task,
-                                               task_cls,
+            GNUNET_SCHEDULER_add_continuation (task, task_cls,
                                                GNUNET_SCHEDULER_REASON_PREREQ_DONE);
             return;
           }
@@ -784,14 +770,11 @@ GNUNET_CLIENT_service_test (const char *service,
 
   hostname = NULL;
   if ((GNUNET_OK !=
-       GNUNET_CONFIGURATION_get_value_number (cfg,
-                                              service,
-                                              "PORT",
-                                              &port)) ||
+       GNUNET_CONFIGURATION_get_value_number (cfg, service, "PORT", &port)) ||
       (port > 65535) ||
       (GNUNET_OK !=
-       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                              service, "HOSTNAME", &hostname)))
+       GNUNET_CONFIGURATION_get_value_string (cfg, service, "HOSTNAME",
+                                              &hostname)))
   {
     /* UNIXPATH failed (if possible) AND IP failed => error */
     service_test_error (task, task_cls);
@@ -818,15 +801,13 @@ GNUNET_CLIENT_service_test (const char *service,
     if (sock != NULL)
     {
       if (GNUNET_OK !=
-          GNUNET_NETWORK_socket_bind (sock,
-                                      (const struct sockaddr *) &s_in,
+          GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) &s_in,
                                       sizeof (s_in)))
       {
         /* failed to bind => service must be running */
         GNUNET_free (hostname);
         (void) GNUNET_NETWORK_socket_close (sock);
-        GNUNET_SCHEDULER_add_continuation (task,
-                                           task_cls,
+        GNUNET_SCHEDULER_add_continuation (task, task_cls,
                                            GNUNET_SCHEDULER_REASON_PREREQ_DONE);
         return;
       }
@@ -854,15 +835,13 @@ GNUNET_CLIENT_service_test (const char *service,
     if (sock != NULL)
     {
       if (GNUNET_OK !=
-          GNUNET_NETWORK_socket_bind (sock,
-                                      (const struct sockaddr *) &s_in6,
+          GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) &s_in6,
                                       sizeof (s_in6)))
       {
         /* failed to bind => service must be running */
         GNUNET_free (hostname);
         (void) GNUNET_NETWORK_socket_close (sock);
-        GNUNET_SCHEDULER_add_continuation (task,
-                                           task_cls,
+        GNUNET_SCHEDULER_add_continuation (task, task_cls,
                                            GNUNET_SCHEDULER_REASON_PREREQ_DONE);
         return;
       }
@@ -889,8 +868,7 @@ GNUNET_CLIENT_service_test (const char *service,
   if (conn == NULL)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _
-                ("Could not connect to service `%s', must not be running.\n"),
+                _("Could not connect to service `%s', must not be running.\n"),
                 service);
     service_test_error (task, task_cls);
     return;
@@ -899,11 +877,11 @@ GNUNET_CLIENT_service_test (const char *service,
   conn->test_cb_cls = task_cls;
   conn->test_deadline = GNUNET_TIME_relative_to_absolute (timeout);
 
-  if (NULL == GNUNET_CLIENT_notify_transmit_ready (conn,
-                                                   sizeof (struct
-                                                           GNUNET_MessageHeader),
-                                                   timeout, GNUNET_YES,
-                                                   &write_test, conn))
+  if (NULL ==
+      GNUNET_CLIENT_notify_transmit_ready (conn,
+                                           sizeof (struct GNUNET_MessageHeader),
+                                           timeout, GNUNET_YES, &write_test,
+                                           conn))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _("Failure to transmit request to service `%s'\n"), service);
@@ -952,8 +930,8 @@ client_delayed_retry (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_free (th);
     return;
   }
-  th->sock->sock = do_connect (th->sock->service_name,
-                               th->sock->cfg, th->sock->attempts++);
+  th->sock->sock =
+      do_connect (th->sock->service_name, th->sock->cfg, th->sock->attempts++);
   if (NULL == th->sock->sock)
   {
     /* could happen if we're out of sockets */
@@ -970,17 +948,16 @@ client_delayed_retry (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                 MAX_ATTEMPTS - th->attempts_left,
                 (unsigned long long) delay.rel_value);
 #endif
-    th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                       &client_delayed_retry,
-                                                       th);
+    th->reconnect_task =
+        GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th);
     return;
   }
   GNUNET_CONNECTION_ignore_shutdown (th->sock->sock, th->sock->ignore_shutdown);
-  th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock,
-                                                    th->size,
-                                                    GNUNET_TIME_absolute_get_remaining
-                                                    (th->timeout),
-                                                    &client_notify, th);
+  th->th =
+      GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock, th->size,
+                                               GNUNET_TIME_absolute_get_remaining
+                                               (th->timeout), &client_notify,
+                                               th);
   if (th->th == NULL)
   {
     GNUNET_break (0);
@@ -1037,8 +1014,7 @@ client_notify (void *cls, size_t size, void *buf)
     GNUNET_CONNECTION_destroy (th->sock->sock, GNUNET_NO);
     th->sock->sock = NULL;
     delay = GNUNET_TIME_relative_min (delay, th->sock->back_off);
-    th->sock->back_off
-        =
+    th->sock->back_off =
         GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply
                                   (th->sock->back_off, 2),
                                   GNUNET_TIME_UNIT_SECONDS);
@@ -1049,9 +1025,8 @@ client_notify (void *cls, size_t size, void *buf)
                 (unsigned long long) delay.rel_value);
 #endif
     th->sock->th = th;
-    th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                       &client_delayed_retry,
-                                                       th);
+    th->reconnect_task =
+        GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th);
     return 0;
   }
   GNUNET_assert (size >= th->size);
@@ -1108,17 +1083,16 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
   sock->th = th;
   if (sock->sock == NULL)
   {
-    th->reconnect_task = GNUNET_SCHEDULER_add_delayed (sock->back_off,
-                                                       &client_delayed_retry,
-                                                       th);
+    th->reconnect_task =
+        GNUNET_SCHEDULER_add_delayed (sock->back_off, &client_delayed_retry,
+                                      th);
 
   }
   else
   {
-    th->th = GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
-                                                      size,
-                                                      timeout,
-                                                      &client_notify, th);
+    th->th =
+        GNUNET_CONNECTION_notify_transmit_ready (sock->sock, size, timeout,
+                                                 &client_notify, th);
     if (NULL == th->th)
     {
       GNUNET_break (0);
@@ -1137,8 +1111,8 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
  * @param th handle from the original request.
  */
 void
-GNUNET_CLIENT_notify_transmit_ready_cancel (struct
-                                            GNUNET_CLIENT_TransmitHandle *th)
+GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle
+                                            *th)
 {
   if (th->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
   {
@@ -1189,9 +1163,7 @@ transmit_for_response (void *cls, size_t size, void *buf)
   }
   GNUNET_assert (size >= msize);
   memcpy (buf, tc->hdr, msize);
-  GNUNET_CLIENT_receive (tc->sock,
-                         tc->rn,
-                         tc->rn_cls,
+  GNUNET_CLIENT_receive (tc->sock, tc->rn, tc->rn_cls,
                          GNUNET_TIME_absolute_get_remaining (tc->timeout));
   GNUNET_free (tc);
   return msize;
@@ -1220,10 +1192,8 @@ transmit_for_response (void *cls, size_t size, void *buf)
  *         is already pending
  */
 int
-GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection
-                                         *sock,
-                                         const struct GNUNET_MessageHeader
-                                         *hdr,
+GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock,
+                                         const struct GNUNET_MessageHeader *hdr,
                                          struct GNUNET_TIME_Relative timeout,
                                          int auto_retry,
                                          GNUNET_CLIENT_MessageHandler rn,
@@ -1243,11 +1213,9 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection
   tc->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   tc->rn = rn;
   tc->rn_cls = rn_cls;
-  if (NULL == GNUNET_CLIENT_notify_transmit_ready (sock,
-                                                   msize,
-                                                   timeout,
-                                                   auto_retry,
-                                                   &transmit_for_response, tc))
+  if (NULL ==
+      GNUNET_CLIENT_notify_transmit_ready (sock, msize, timeout, auto_retry,
+                                           &transmit_for_response, tc))
   {
     GNUNET_break (0);
     GNUNET_free (tc);
diff --git a/src/util/common_allocation.c b/src/util/common_allocation.c
index 6f01e8230..71aa15add 100644
--- a/src/util/common_allocation.c
+++ b/src/util/common_allocation.c
@@ -255,9 +255,7 @@ GNUNET_xstrndup_ (const char *str, size_t len, const char *filename,
  * @param linenumber where in the code was the call to GNUNET_array_grow
  */
 void
-GNUNET_xgrow_ (void **old,
-               size_t elementSize,
-               unsigned int *oldCount,
+GNUNET_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount,
                unsigned int newCount, const char *filename, int linenumber)
 {
   void *tmp;
diff --git a/src/util/common_logging.c b/src/util/common_logging.c
index 37f630854..ff3ac12ee 100644
--- a/src/util/common_logging.c
+++ b/src/util/common_logging.c
@@ -279,8 +279,8 @@ GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
  * @param msg the actual message
  */
 static void
-output_message (enum GNUNET_ErrorType kind,
-                const char *comp, const char *datestr, const char *msg)
+output_message (enum GNUNET_ErrorType kind, const char *comp,
+                const char *datestr, const char *msg)
 {
   struct CustomLogger *pos;
 
@@ -371,8 +371,8 @@ GNUNET_log_skip (unsigned int n, int check_reset)
  * @param va arguments to the format string "message"
  */
 static void
-mylog (enum GNUNET_ErrorType kind,
-       const char *comp, const char *message, va_list va)
+mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
+       va_list va)
 {
   char date[DATE_STR_SIZE];
   char date2[DATE_STR_SIZE];
@@ -419,9 +419,8 @@ mylog (enum GNUNET_ErrorType kind,
   }
   else
     strcpy (date, "localtime error");
-  if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
-      (last_bulk_time.abs_value != 0) &&
-      (0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
+  if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) && (last_bulk_time.abs_value != 0)
+      && (0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
   {
     last_bulk_repeat++;
     if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value >
@@ -469,8 +468,8 @@ GNUNET_log (enum GNUNET_ErrorType kind, const char *message, ...)
  * @param ... arguments for format string
  */
 void
-GNUNET_log_from (enum GNUNET_ErrorType kind,
-                 const char *comp, const char *message, ...)
+GNUNET_log_from (enum GNUNET_ErrorType kind, const char *comp,
+                 const char *message, ...)
 {
   va_list va;
   char comp_w_pid[128];
@@ -614,10 +613,7 @@ GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
     off = 0;
     if (un->sun_path[0] == '\0')
       off++;
-    snprintf (buf,
-              sizeof (buf),
-              "%s%.*s",
-              (off == 1) ? "@" : "",
+    snprintf (buf, sizeof (buf), "%s%.*s", (off == 1) ? "@" : "",
               (int) (addrlen - sizeof (sa_family_t) - 1 - off),
               &un->sun_path[off]);
     return buf;
diff --git a/src/util/configuration.c b/src/util/configuration.c
index b3b9d5ea8..534949652 100644
--- a/src/util/configuration.c
+++ b/src/util/configuration.c
@@ -241,8 +241,7 @@ GNUNET_CONFIGURATION_parse (struct GNUNET_CONFIGURATION_Handle *cfg,
     {
       /* parse error */
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _
-                  ("Syntax error in configuration file `%s' at line %u.\n"),
+                  _("Syntax error in configuration file `%s' at line %u.\n"),
                   filename, nr);
       ret = GNUNET_SYSERR;
       break;
@@ -499,8 +498,8 @@ GNUNET_CONFIGURATION_remove_section (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param value value to copy 
  */
 static void
-copy_entry (void *cls,
-            const char *section, const char *option, const char *value)
+copy_entry (void *cls, const char *section, const char *option,
+            const char *value)
 {
   struct GNUNET_CONFIGURATION_Handle *dst = cls;
 
@@ -553,8 +552,8 @@ findSection (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
  * @return matching entry, NULL if not found
  */
 static struct ConfigEntry *
-findEntry (const struct GNUNET_CONFIGURATION_Handle *cfg,
-           const char *section, const char *key)
+findEntry (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section,
+           const char *key)
 {
   struct ConfigSection *sec;
   struct ConfigEntry *pos;
@@ -580,8 +579,8 @@ findEntry (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param value value to copy (of the default conf.)
  */
 static void
-compareEntries (void *cls,
-                const char *section, const char *option, const char *value)
+compareEntries (void *cls, const char *section, const char *option,
+                const char *value)
 {
   struct DiffHandle *dh = cls;
   struct ConfigEntry *entNew;
@@ -627,10 +626,9 @@ GNUNET_CONFIGURATION_write_diffs (const struct GNUNET_CONFIGURATION_Handle
  * @param value value to set
  */
 void
-GNUNET_CONFIGURATION_set_value_string (struct GNUNET_CONFIGURATION_Handle
-                                       *cfg,
-                                       const char *section,
-                                       const char *option, const char *value)
+GNUNET_CONFIGURATION_set_value_string (struct GNUNET_CONFIGURATION_Handle *cfg,
+                                       const char *section, const char *option,
+                                       const char *value)
 {
   struct ConfigSection *sec;
   struct ConfigEntry *e;
@@ -667,9 +665,8 @@ GNUNET_CONFIGURATION_set_value_string (struct GNUNET_CONFIGURATION_Handle
  * @param number value to set
  */
 void
-GNUNET_CONFIGURATION_set_value_number (struct GNUNET_CONFIGURATION_Handle
-                                       *cfg, const char *section,
-                                       const char *option,
+GNUNET_CONFIGURATION_set_value_number (struct GNUNET_CONFIGURATION_Handle *cfg,
+                                       const char *section, const char *option,
                                        unsigned long long number)
 {
   char s[64];
@@ -689,9 +686,8 @@ GNUNET_CONFIGURATION_set_value_number (struct GNUNET_CONFIGURATION_Handle
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_number (const struct
-                                       GNUNET_CONFIGURATION_Handle *cfg,
-                                       const char *section,
+GNUNET_CONFIGURATION_get_value_number (const struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *section,
                                        const char *option,
                                        unsigned long long *number)
 {
@@ -751,9 +747,8 @@ GNUNET_CONFIGURATION_get_value_time (const struct GNUNET_CONFIGURATION_Handle
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_string (const struct
-                                       GNUNET_CONFIGURATION_Handle *cfg,
-                                       const char *section,
+GNUNET_CONFIGURATION_get_value_string (const struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *section,
                                        const char *option, char **value)
 {
   struct ConfigEntry *e;
@@ -782,11 +777,10 @@ GNUNET_CONFIGURATION_get_value_string (const struct
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_choice (const struct
-                                       GNUNET_CONFIGURATION_Handle *cfg,
-                                       const char *section,
-                                       const char *option,
-                                       const char **choices, const char **value)
+GNUNET_CONFIGURATION_get_value_choice (const struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *section,
+                                       const char *option, const char **choices,
+                                       const char **value)
 {
   struct ConfigEntry *e;
   int i;
@@ -805,8 +799,8 @@ GNUNET_CONFIGURATION_get_value_choice (const struct
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _("Configuration value '%s' for '%s'"
-                  " in section '%s' is not in set of legal choices\n"),
-                e->val, option, section);
+                  " in section '%s' is not in set of legal choices\n"), e->val,
+                option, section);
     return GNUNET_SYSERR;
   }
   *value = choices[i];
@@ -822,8 +816,8 @@ GNUNET_CONFIGURATION_get_value_choice (const struct
  * @return GNUNET_YES if so, GNUNET_NO if not.
  */
 int
-GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle
-                                 *cfg, const char *section, const char *option)
+GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                 const char *section, const char *option)
 {
   struct ConfigEntry *e;
 
@@ -866,9 +860,8 @@ GNUNET_CONFIGURATION_expand_dollar (const struct GNUNET_CONFIGURATION_Handle
     orig[i] = '\0';
     post = &orig[i + 1];
   }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                            "PATHS",
-                                                            &orig[1], &prefix))
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "PATHS", &orig[1], &prefix))
   {
     if (NULL == (env = getenv (&orig[1])))
     {
@@ -940,8 +933,8 @@ GNUNET_CONFIGURATION_get_value_yesno (const struct GNUNET_CONFIGURATION_Handle
   const char *val;
   int ret;
 
-  ret = GNUNET_CONFIGURATION_get_value_choice (cfg,
-                                               section, option, yesno, &val);
+  ret =
+      GNUNET_CONFIGURATION_get_value_choice (cfg, section, option, yesno, &val);
   if (ret == GNUNET_SYSERR)
     return ret;
   if (val == yesno[0])
@@ -962,8 +955,8 @@ GNUNET_CONFIGURATION_get_value_yesno (const struct GNUNET_CONFIGURATION_Handle
  */
 int
 GNUNET_CONFIGURATION_iterate_value_filenames (const struct
-                                              GNUNET_CONFIGURATION_Handle
-                                              *cfg, const char *section,
+                                              GNUNET_CONFIGURATION_Handle *cfg,
+                                              const char *section,
                                               const char *option,
                                               GNUNET_FileNameCallback cb,
                                               void *cb_cls)
@@ -1093,8 +1086,7 @@ test_match (void *cls, const char *fn)
  */
 int
 GNUNET_CONFIGURATION_append_value_filename (struct GNUNET_CONFIGURATION_Handle
-                                            *cfg,
-                                            const char *section,
+                                            *cfg, const char *section,
                                             const char *option,
                                             const char *value)
 {
@@ -1102,12 +1094,10 @@ GNUNET_CONFIGURATION_append_value_filename (struct GNUNET_CONFIGURATION_Handle
   char *old;
   char *nw;
 
-  if (GNUNET_SYSERR
-      == GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
-                                                       section,
-                                                       option,
-                                                       &test_match,
-                                                       (void *) value))
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_iterate_value_filenames (cfg, section, option,
+                                                    &test_match,
+                                                    (void *) value))
     return GNUNET_NO;           /* already exists */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &old))
@@ -1140,8 +1130,7 @@ GNUNET_CONFIGURATION_append_value_filename (struct GNUNET_CONFIGURATION_Handle
  */
 int
 GNUNET_CONFIGURATION_remove_value_filename (struct GNUNET_CONFIGURATION_Handle
-                                            *cfg,
-                                            const char *section,
+                                            *cfg, const char *section,
                                             const char *option,
                                             const char *value)
 {
@@ -1231,11 +1220,10 @@ GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg,
   if (ipath == NULL)
     return GNUNET_SYSERR;
   baseconfig = NULL;
-  GNUNET_asprintf (&baseconfig,
-                   "%s%s%s", ipath, DIR_SEPARATOR_STR, "defaults.conf");
+  GNUNET_asprintf (&baseconfig, "%s%s%s", ipath, DIR_SEPARATOR_STR,
+                   "defaults.conf");
   GNUNET_free (ipath);
-  if ((GNUNET_OK !=
-       GNUNET_CONFIGURATION_parse (cfg, baseconfig)) ||
+  if ((GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, baseconfig)) ||
       (!((filename == NULL) ||
          (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, filename)))))
   {
@@ -1243,18 +1231,15 @@ GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg,
     return (filename == NULL) ? GNUNET_OK : GNUNET_SYSERR;
   }
   GNUNET_free (baseconfig);
-  if (((GNUNET_YES != GNUNET_CONFIGURATION_have_value (cfg,
-                                                       "PATHS",
-                                                       "DEFAULTCONFIG"))) &&
+  if (((GNUNET_YES !=
+        GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "DEFAULTCONFIG"))) &&
       (filename != NULL))
-    GNUNET_CONFIGURATION_set_value_string (cfg,
-                                           "PATHS", "DEFAULTCONFIG", filename);
-  if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (cfg,
-                                                      "TESTING",
-                                                      "WEAKRANDOM")) &&
-      (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                           "TESTING",
-                                                           "WEAKRANDOM")))
+    GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
+                                           filename);
+  if ((GNUNET_YES ==
+       GNUNET_CONFIGURATION_have_value (cfg, "TESTING", "WEAKRANDOM")) &&
+      (GNUNET_YES ==
+       GNUNET_CONFIGURATION_get_value_yesno (cfg, "TESTING", "WEAKRANDOM")))
     GNUNET_CRYPTO_random_disable_entropy_gathering ();
   return GNUNET_OK;
 }
diff --git a/src/util/connection.c b/src/util/connection.c
index 1ac1b2304..39cb1dde2 100644
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -425,9 +425,8 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
     /* largely traditional GNU/Linux */
     olen = sizeof (uc);
     if ((0 ==
-         getsockopt (GNUNET_NETWORK_get_fd (sock),
-                     SOL_SOCKET, SO_PEERCRED, &uc, &olen)) &&
-        (olen == sizeof (uc)))
+         getsockopt (GNUNET_NETWORK_get_fd (sock), SOL_SOCKET, SO_PEERCRED, &uc,
+                     &olen)) && (olen == sizeof (uc)))
     {
       gc.uid = uc.uid;
       gc.gid = uc.gid;
@@ -455,8 +454,8 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
       (GNUNET_YES != (aret = access (access_cls, gcp, uaddr, addrlen))))
   {
     if (aret == GNUNET_NO)
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Access denied to `%s'\n"), GNUNET_a2s (uaddr, addrlen));
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Access denied to `%s'\n"),
+                  GNUNET_a2s (uaddr, addrlen));
     GNUNET_break (GNUNET_OK ==
                   GNUNET_NETWORK_socket_shutdown (sock, SHUT_RDWR));
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
@@ -470,8 +469,7 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
   ret->addrlen = addrlen;
   ret->sock = sock;
 #if DEBUG_CONNECTION
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Accepting connection from `%s': %p\n"),
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Accepting connection from `%s': %p\n"),
               GNUNET_a2s (uaddr, addrlen), ret);
 #endif
   return ret;
@@ -508,8 +506,8 @@ GNUNET_CONNECTION_get_address (struct GNUNET_CONNECTION_Handle *sock,
  * @param cls our connection handle
  * @param tc task context describing why we are here
  */
-static void
-receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+static void receive_again (void *cls,
+                           const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -544,9 +542,9 @@ destroy_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                 "Destroy waits for write_task to be done (%p)\n", sock);
 #endif
     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
-    sock->destroy_task
-        = GNUNET_SCHEDULER_add_after (sock->write_task,
-                                      &destroy_continuation, sock);
+    sock->destroy_task =
+        GNUNET_SCHEDULER_add_after (sock->write_task, &destroy_continuation,
+                                    sock);
     return;
   }
   if (0 != (sock->ccs & COCO_RECEIVE_AGAIN))
@@ -569,9 +567,9 @@ destroy_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
   {
     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
-    sock->destroy_task
-        = GNUNET_SCHEDULER_add_after (sock->read_task,
-                                      &destroy_continuation, sock);
+    sock->destroy_task =
+        GNUNET_SCHEDULER_add_after (sock->read_task, &destroy_continuation,
+                                    sock);
     return;
   }
 #if DEBUG_CONNECTION
@@ -604,8 +602,8 @@ destroy_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_free_non_null (sock->hostname);
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
 #if DEBUG_CONNECTION
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Freeing memory of connection %p.\n", sock);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Freeing memory of connection %p.\n",
+              sock);
 #endif
   GNUNET_free (sock->write_buffer);
   GNUNET_free (sock);
@@ -621,8 +619,8 @@ destroy_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param cls our connection handle
  * @param tc task context describing why we are here
  */
-static void
-transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+static void transmit_ready (void *cls,
+                            const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -634,11 +632,10 @@ static void
 connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h)
 {
 #if DEBUG_CONNECTION
-  GNUNET_log ((0 != strncmp (h->hostname,
-                             "localhost:",
-                             10))
-              ? GNUNET_ERROR_TYPE_INFO
-              : GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log ((0 !=
+               strncmp (h->hostname, "localhost:",
+                        10)) ? GNUNET_ERROR_TYPE_INFO :
+              GNUNET_ERROR_TYPE_WARNING,
               _
               ("Failed to establish TCP connection to `%s:%u', no further addresses to try.\n"),
               h->hostname, h->port);
@@ -697,8 +694,7 @@ static void
 connect_success_continuation (struct GNUNET_CONNECTION_Handle *h)
 {
 #if DEBUG_CONNECTION
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connection to `%s' succeeded! (%p)\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connection to `%s' succeeded! (%p)\n",
               GNUNET_a2s (h->addr, h->addrlen), h);
 #endif
   /* trigger jobs that waited for the connection */
@@ -767,8 +763,8 @@ connect_probe_continuation (void *cls,
   error = 0;
   if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
       (GNUNET_OK !=
-       GNUNET_NETWORK_socket_getsockopt (ap->sock, SOL_SOCKET, SO_ERROR,
-                                         &error, &len)) || (error != 0))
+       GNUNET_NETWORK_socket_getsockopt (ap->sock, SOL_SOCKET, SO_ERROR, &error,
+                                         &len)) || (error != 0))
   {
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ap->sock));
     GNUNET_free (ap);
@@ -804,8 +800,8 @@ connect_probe_continuation (void *cls,
  * @param addrlen length of addr
  */
 static void
-try_connect_using_address (void *cls,
-                           const struct sockaddr *addr, socklen_t addrlen)
+try_connect_using_address (void *cls, const struct sockaddr *addr,
+                           socklen_t addrlen)
 {
   struct GNUNET_CONNECTION_Handle *h = cls;
   struct AddressProbe *ap;
@@ -824,8 +820,8 @@ try_connect_using_address (void *cls,
   /* try to connect */
 #if DEBUG_CONNECTION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Trying to connect using address `%s:%u/%s:%u'\n",
-              h->hostname, h->port, GNUNET_a2s (addr, addrlen), h->port);
+              "Trying to connect using address `%s:%u/%s:%u'\n", h->hostname,
+              h->port, GNUNET_a2s (addr, addrlen), h->port);
 #endif
   ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);
   ap->addr = (const struct sockaddr *) &ap[1];
@@ -853,13 +849,11 @@ try_connect_using_address (void *cls,
     return;                     /* not supported by OS */
   }
 #if DEBUG_CONNECTION
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Trying to connect to `%s' (%p)\n"),
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Trying to connect to `%s' (%p)\n"),
               GNUNET_a2s (ap->addr, ap->addrlen), h);
 #endif
-  if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (ap->sock,
-                                                   ap->addr,
-                                                   ap->addrlen)) &&
+  if ((GNUNET_OK !=
+       GNUNET_NETWORK_socket_connect (ap->sock, ap->addr, ap->addrlen)) &&
       (errno != EINPROGRESS))
   {
     /* maybe refused / unsupported address, try next */
@@ -871,13 +865,15 @@ try_connect_using_address (void *cls,
   GNUNET_CONTAINER_DLL_insert (h->ap_head, h->ap_tail, ap);
   delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT;
   if (h->nth.notify_ready != NULL)
-    delay = GNUNET_TIME_relative_min (delay,
-                                      GNUNET_TIME_absolute_get_remaining
-                                      (h->nth.transmit_timeout));
+    delay =
+        GNUNET_TIME_relative_min (delay,
+                                  GNUNET_TIME_absolute_get_remaining (h->nth.
+                                                                      transmit_timeout));
   if (h->receiver != NULL)
-    delay = GNUNET_TIME_relative_min (delay,
-                                      GNUNET_TIME_absolute_get_remaining
-                                      (h->receive_timeout));
+    delay =
+        GNUNET_TIME_relative_min (delay,
+                                  GNUNET_TIME_absolute_get_remaining (h->
+                                                                      receive_timeout));
   ap->task =
       GNUNET_SCHEDULER_add_write_net (delay, ap->sock,
                                       &connect_probe_continuation, ap);
@@ -895,9 +891,9 @@ try_connect_using_address (void *cls,
  * @return the socket handle
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_connect (const struct
-                                       GNUNET_CONFIGURATION_Handle *cfg,
-                                       const char *hostname, uint16_t port)
+GNUNET_CONNECTION_create_from_connect (const struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *hostname,
+                                       uint16_t port)
 {
   struct GNUNET_CONNECTION_Handle *ret;
 
@@ -908,10 +904,10 @@ GNUNET_CONNECTION_create_from_connect (const struct
   ret->write_buffer = GNUNET_malloc (ret->write_buffer_size);
   ret->port = port;
   ret->hostname = GNUNET_strdup (hostname);
-  ret->dns_active = GNUNET_RESOLVER_ip_get (ret->hostname,
-                                            AF_UNSPEC,
-                                            GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
-                                            &try_connect_using_address, ret);
+  ret->dns_active =
+      GNUNET_RESOLVER_ip_get (ret->hostname, AF_UNSPEC,
+                              GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
+                              &try_connect_using_address, ret);
   return ret;
 }
 
@@ -966,8 +962,8 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
     GNUNET_free (ret);
     return NULL;
   }
-  if (GNUNET_OK != GNUNET_NETWORK_socket_connect (ret->sock,
-                                                  ret->addr, ret->addrlen))
+  if (GNUNET_OK !=
+      GNUNET_NETWORK_socket_connect (ret->sock, ret->addr, ret->addrlen))
   {
     /* Just return; we expect everything to work eventually so don't fail HARD */
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret->sock));
@@ -1004,18 +1000,18 @@ GNUNET_CONNECTION_create_from_sockaddr (int af_family,
   s = GNUNET_NETWORK_socket_create (af_family, SOCK_STREAM, 0);
   if (s == NULL)
   {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
-                         GNUNET_ERROR_TYPE_BULK, "socket");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                         "socket");
     return NULL;
   }
-  if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen))
-      && (errno != EINPROGRESS))
+  if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen)) &&
+      (errno != EINPROGRESS))
   {
     /* maybe refused / unsupported address, try next */
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "connect");
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Attempt to connect to `%s' failed\n"),
-                GNUNET_a2s (serv_addr, addrlen));
+                _("Attempt to connect to `%s' failed\n"), GNUNET_a2s (serv_addr,
+                                                                      addrlen));
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
     return NULL;
   }
@@ -1024,8 +1020,7 @@ GNUNET_CONNECTION_create_from_sockaddr (int af_family,
   memcpy (ret->addr, serv_addr, addrlen);
   ret->addrlen = addrlen;
 #if DEBUG_CONNECTION
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Trying to connect to `%s' (%p)\n"),
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Trying to connect to `%s' (%p)\n"),
               GNUNET_a2s (serv_addr, addrlen), ret);
 #endif
   return ret;
@@ -1157,8 +1152,9 @@ receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Receive from `%s' encounters error: time out by %llums... (%p)\n",
                   GNUNET_a2s (sh->addr, sh->addrlen),
-                  GNUNET_TIME_absolute_get_duration (sh->receive_timeout).
-                  rel_value, sh);
+                  GNUNET_TIME_absolute_get_duration (sh->
+                                                     receive_timeout).rel_value,
+                  sh);
 #endif
     signal_timeout (sh);
     return;
@@ -1181,8 +1177,8 @@ RETRY:
     if (errno == EINTR)
       goto RETRY;
 #if DEBUG_CONNECTION
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Error receiving: %s\n", STRERROR (errno));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error receiving: %s\n",
+                STRERROR (errno));
 #endif
     signal_error (sh, errno);
     return;
@@ -1190,8 +1186,8 @@ RETRY:
 #if DEBUG_CONNECTION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "receive_ready read %u/%u bytes from `%s' (%p)!\n",
-              (unsigned int) ret,
-              sh->max, GNUNET_a2s (sh->addr, sh->addrlen), sh);
+              (unsigned int) ret, sh->max, GNUNET_a2s (sh->addr, sh->addrlen),
+              sh);
 #endif
   GNUNET_assert (NULL != (receiver = sh->receiver));
   sh->receiver = NULL;
@@ -1260,8 +1256,7 @@ receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param receiver_cls closure for receiver
  */
 void
-GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *sock,
-                           size_t max,
+GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *sock, size_t max,
                            struct GNUNET_TIME_Relative timeout,
                            GNUNET_CONNECTION_Receiver receiver,
                            void *receiver_cls)
@@ -1358,15 +1353,16 @@ process_notify (struct GNUNET_CONNECTION_Handle *sock)
   if (sock->write_buffer_size - sock->write_buffer_off < size)
   {
     /* need to compact */
-    memmove (sock->write_buffer,
-             &sock->write_buffer[sock->write_buffer_pos], used);
+    memmove (sock->write_buffer, &sock->write_buffer[sock->write_buffer_pos],
+             used);
     sock->write_buffer_off -= sock->write_buffer_pos;
     sock->write_buffer_pos = 0;
   }
   avail = sock->write_buffer_size - sock->write_buffer_off;
   GNUNET_assert (avail >= size);
-  size = notify (sock->nth.notify_ready_cls,
-                 avail, &sock->write_buffer[sock->write_buffer_off]);
+  size =
+      notify (sock->nth.notify_ready_cls, avail,
+              &sock->write_buffer[sock->write_buffer_off]);
   GNUNET_assert (size <= avail);
   sock->write_buffer_off += size;
   return GNUNET_YES;
@@ -1397,8 +1393,8 @@ transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #if DEBUG_CONNECTION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Transmit to `%s:%u/%s' fails, time out reached (%p).\n",
-              sock->hostname,
-              sock->port, GNUNET_a2s (sock->addr, sock->addrlen), sock);
+              sock->hostname, sock->port, GNUNET_a2s (sock->addr,
+                                                      sock->addrlen), sock);
 #endif
   GNUNET_assert (0 != (sock->ccs & COCO_TRANSMIT_READY));
   sock->ccs -= COCO_TRANSMIT_READY;     /* remove request */
@@ -1541,8 +1537,8 @@ transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if ((sock->nth.notify_ready != NULL) &&
       (sock->write_buffer_size < sock->nth.notify_size))
   {
-    sock->write_buffer = GNUNET_realloc (sock->write_buffer,
-                                         sock->nth.notify_size);
+    sock->write_buffer =
+        GNUNET_realloc (sock->write_buffer, sock->nth.notify_size);
     sock->write_buffer_size = sock->nth.notify_size;
   }
   process_notify (sock);
@@ -1556,9 +1552,10 @@ transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (have + sock->write_buffer_pos <= sock->write_buffer_size);
   GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size);
 RETRY:
-  ret = GNUNET_NETWORK_socket_send (sock->sock,
-                                    &sock->write_buffer[sock->write_buffer_pos],
-                                    have);
+  ret =
+      GNUNET_NETWORK_socket_send (sock->sock,
+                                  &sock->write_buffer[sock->write_buffer_pos],
+                                  have);
   if (ret == -1)
   {
     if (errno == EINTR)
@@ -1566,8 +1563,7 @@ RETRY:
 #if 0
     int en = errno;
 
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to send to `%s': %s\n"),
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to send to `%s': %s\n"),
                 GNUNET_a2s (sock->addr, sock->addrlen), STRERROR (en));
 #endif
 #if DEBUG_CONNECTION
@@ -1579,8 +1575,8 @@ RETRY:
 #if DEBUG_CONNECTION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "transmit_ready transmitted %u/%u bytes to `%s' (%p)\n",
-              (unsigned int) ret,
-              have, GNUNET_a2s (sock->addr, sock->addrlen), sock);
+              (unsigned int) ret, have, GNUNET_a2s (sock->addr, sock->addrlen),
+              sock);
 #endif
   sock->write_buffer_pos += ret;
   if (sock->write_buffer_pos == sock->write_buffer_off)
@@ -1601,9 +1597,8 @@ SCHEDULE_WRITE:
   GNUNET_assert ((sock->nth.notify_ready != NULL) || (have > 0));
   if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
     sock->write_task =
-        GNUNET_SCHEDULER_add_write_net ((sock->nth.notify_ready == NULL)
-                                        ? GNUNET_TIME_UNIT_FOREVER_REL
-                                        :
+        GNUNET_SCHEDULER_add_write_net ((sock->nth.notify_ready ==
+                                         NULL) ? GNUNET_TIME_UNIT_FOREVER_REL :
                                         GNUNET_TIME_absolute_get_remaining
                                         (sock->nth.transmit_timeout),
                                         sock->sock, &transmit_ready, sock);
@@ -1625,8 +1620,8 @@ SCHEDULE_WRITE:
  *         NULL if we are already going to notify someone else (busy)
  */
 struct GNUNET_CONNECTION_TransmitHandle *
-GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
-                                         *sock, size_t size,
+GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle *sock,
+                                         size_t size,
                                          struct GNUNET_TIME_Relative timeout,
                                          GNUNET_CONNECTION_TransmitReadyNotify
                                          notify, void *notify_cls)
@@ -1647,8 +1642,8 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
   sock->nth.notify_size = size;
   sock->nth.transmit_timeout = GNUNET_TIME_relative_to_absolute (timeout);
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->nth.timeout_task);
-  if ((sock->sock == NULL) &&
-      (sock->ap_head == NULL) && (sock->dns_active == NULL))
+  if ((sock->sock == NULL) && (sock->ap_head == NULL) &&
+      (sock->dns_active == NULL))
   {
     if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
       GNUNET_SCHEDULER_cancel (sock->write_task);
@@ -1660,8 +1655,8 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
   if (sock->sock != NULL)
   {
 #if DEBUG_CONNECTION
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Scheduling transmit_ready (%p).\n", sock);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Scheduling transmit_ready (%p).\n",
+                sock);
 #endif
     sock->write_task =
         GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
@@ -1676,9 +1671,8 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
                 sock);
 #endif
     sock->ccs |= COCO_TRANSMIT_READY;
-    sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                                           &transmit_timeout,
-                                                           sock);
+    sock->nth.timeout_task =
+        GNUNET_SCHEDULER_add_delayed (timeout, &transmit_timeout, sock);
   }
   return &sock->nth;
 }
diff --git a/src/util/container_bloomfilter.c b/src/util/container_bloomfilter.c
index a0749a18a..ebd056128 100644
--- a/src/util/container_bloomfilter.c
+++ b/src/util/container_bloomfilter.c
@@ -102,8 +102,7 @@ struct GNUNET_CONTAINER_BloomFilter *
 GNUNET_CONTAINER_bloomfilter_copy (const struct GNUNET_CONTAINER_BloomFilter
                                    *bf)
 {
-  return GNUNET_CONTAINER_bloomfilter_init (bf->bitArray,
-                                            bf->bitArraySize,
+  return GNUNET_CONTAINER_bloomfilter_init (bf->bitArray, bf->bitArraySize,
                                             bf->addressesPerElement);
 }
 
@@ -209,9 +208,8 @@ incrementBit (char *bitArray, unsigned int bitIdx,
       high++;
   }
   value = ((high << 4) | low);
-  GNUNET_assert (fileSlot == GNUNET_DISK_file_seek (fh,
-                                                    fileSlot,
-                                                    GNUNET_DISK_SEEK_SET));
+  GNUNET_assert (fileSlot ==
+                 GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_DISK_SEEK_SET));
   GNUNET_assert (1 == GNUNET_DISK_file_write (fh, &value, 1));
 }
 
@@ -348,8 +346,7 @@ iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
   {
     while (slot < (sizeof (GNUNET_HashCode) / sizeof (uint32_t)))
     {
-      callback (arg,
-                bf,
+      callback (arg, bf,
                 (((uint32_t *) & tmp[round & 1])[slot]) &
                 ((bf->bitArraySize * 8) - 1));
       slot++;
@@ -375,8 +372,7 @@ iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
  * @param bit the bit to increment
  */
 static void
-incrementBitCallback (void *cls,
-                      const struct GNUNET_CONTAINER_BloomFilter *bf,
+incrementBitCallback (void *cls, const struct GNUNET_CONTAINER_BloomFilter *bf,
                       unsigned int bit)
 {
   struct GNUNET_CONTAINER_BloomFilter *b = cls;
@@ -392,8 +388,7 @@ incrementBitCallback (void *cls,
  * @param bit the bit to decrement
  */
 static void
-decrementBitCallback (void *cls,
-                      const struct GNUNET_CONTAINER_BloomFilter *bf,
+decrementBitCallback (void *cls, const struct GNUNET_CONTAINER_BloomFilter *bf,
                       unsigned int bit)
 {
   struct GNUNET_CONTAINER_BloomFilter *b = cls;
@@ -409,8 +404,7 @@ decrementBitCallback (void *cls,
  * @param bit the bit to test
  */
 static void
-testBitCallback (void *cls,
-                 const struct GNUNET_CONTAINER_BloomFilter *bf,
+testBitCallback (void *cls, const struct GNUNET_CONTAINER_BloomFilter *bf,
                  unsigned int bit)
 {
   int *arg = cls;
@@ -432,8 +426,8 @@ testBitCallback (void *cls,
  * @return the bloomfilter
  */
 struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_load (const char *filename,
-                                   size_t size, unsigned int k)
+GNUNET_CONTAINER_bloomfilter_load (const char *filename, size_t size,
+                                   unsigned int k)
 {
   struct GNUNET_CONTAINER_BloomFilter *bf;
   char *rbuff;
@@ -453,10 +447,12 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename,
 
   bf = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_BloomFilter));
   /* Try to open a bloomfilter file */
-  bf->fh = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READWRITE
-                                  | GNUNET_DISK_OPEN_CREATE,
-                                  GNUNET_DISK_PERM_USER_READ |
-                                  GNUNET_DISK_PERM_USER_WRITE);
+  bf->fh =
+      GNUNET_DISK_file_open (filename,
+                             GNUNET_DISK_OPEN_READWRITE |
+                             GNUNET_DISK_OPEN_CREATE,
+                             GNUNET_DISK_PERM_USER_READ |
+                             GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == bf->fh)
   {
     GNUNET_free (bf);
@@ -487,8 +483,8 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename,
     res = GNUNET_DISK_file_read (bf->fh, rbuff, BUFFSIZE);
     if (res == -1)
     {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                "read", bf->filename);
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "read",
+                                bf->filename);
     }
     if (res == 0)
       break;                    /* is ok! we just did not use that many bits yet */
@@ -522,8 +518,8 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename,
  * @return the bloomfilter
  */
 struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_init (const char *data,
-                                   size_t size, unsigned int k)
+GNUNET_CONTAINER_bloomfilter_init (const char *data, size_t size,
+                                   unsigned int k)
 {
   struct GNUNET_CONTAINER_BloomFilter *bf;
   size_t ui;
@@ -752,8 +748,8 @@ GNUNET_CONTAINER_bloomfilter_remove (struct GNUNET_CONTAINER_BloomFilter *bf,
 void
 GNUNET_CONTAINER_bloomfilter_resize (struct GNUNET_CONTAINER_BloomFilter *bf,
                                      GNUNET_HashCodeIterator iterator,
-                                     void *iterator_cls,
-                                     size_t size, unsigned int k)
+                                     void *iterator_cls, size_t size,
+                                     unsigned int k)
 {
   GNUNET_HashCode hc;
   unsigned int i;
diff --git a/src/util/container_heap.c b/src/util/container_heap.c
index c1d478e06..ef6bcc892 100644
--- a/src/util/container_heap.c
+++ b/src/util/container_heap.c
@@ -218,11 +218,11 @@ node_iterator (const struct GNUNET_CONTAINER_Heap *heap,
 {
   if (node == NULL)
     return GNUNET_YES;
-  if (GNUNET_YES != node_iterator (heap,
-                                   node->left_child, iterator, iterator_cls))
+  if (GNUNET_YES !=
+      node_iterator (heap, node->left_child, iterator, iterator_cls))
     return GNUNET_NO;
-  if (GNUNET_YES != node_iterator (heap,
-                                   node->right_child, iterator, iterator_cls))
+  if (GNUNET_YES !=
+      node_iterator (heap, node->right_child, iterator, iterator_cls))
     return GNUNET_NO;
   return iterator (iterator_cls, node, node->element, node->cost);
 }
@@ -267,9 +267,10 @@ GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *heap)
   if (pos == NULL)
     pos = heap->root;
   element = pos->element;
-  heap->walk_pos
-      = (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2))
-      ? pos->right_child : pos->left_child;
+  heap->walk_pos =
+      (0 ==
+       GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                 2)) ? pos->right_child : pos->left_child;
   return element;
 }
 
@@ -290,8 +291,12 @@ insert_node (struct GNUNET_CONTAINER_Heap *heap,
   struct GNUNET_CONTAINER_HeapNode *parent;
 
   GNUNET_assert (node->parent == NULL);
-  while ((heap->order == GNUNET_CONTAINER_HEAP_ORDER_MAX)
-         ? (pos->cost >= node->cost) : (pos->cost <= node->cost))
+  while ((heap->order == GNUNET_CONTAINER_HEAP_ORDER_MAX) ? (pos->cost >=
+                                                             node->
+                                                             cost) : (pos->
+                                                                      cost <=
+                                                                      node->
+                                                                      cost))
   {
     /* node is descendent of pos */
     pos->tree_size += (1 + node->tree_size);
@@ -343,8 +348,8 @@ insert_node (struct GNUNET_CONTAINER_Heap *heap,
  * @return node for the new element
  */
 struct GNUNET_CONTAINER_HeapNode *
-GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *heap,
-                              void *element, GNUNET_CONTAINER_HeapCostType cost)
+GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *heap, void *element,
+                              GNUNET_CONTAINER_HeapCostType cost)
 {
   struct GNUNET_CONTAINER_HeapNode *node;
 
@@ -399,8 +404,7 @@ GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *heap)
   }
   GNUNET_free (root);
 #if DEBUG
-  GNUNET_assert (((heap->size == 0) &&
-                  (heap->root == NULL)) ||
+  GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
                  (heap->size == heap->root->tree_size + 1));
   CHECK (heap->root);
 #endif
@@ -502,8 +506,7 @@ GNUNET_CONTAINER_heap_remove_node (struct GNUNET_CONTAINER_HeapNode *node)
   GNUNET_free (node);
 #if DEBUG
   CHECK (heap->root);
-  GNUNET_assert (((heap->size == 0) &&
-                  (heap->root == NULL)) ||
+  GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
                  (heap->size == heap->root->tree_size + 1));
 #endif
   return ret;
@@ -523,16 +526,14 @@ GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_Heap *heap,
                                    GNUNET_CONTAINER_HeapCostType new_cost)
 {
 #if DEBUG
-  GNUNET_assert (((heap->size == 0) &&
-                  (heap->root == NULL)) ||
+  GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
                  (heap->size == heap->root->tree_size + 1));
   CHECK (heap->root);
 #endif
   remove_node (node);
 #if DEBUG
   CHECK (heap->root);
-  GNUNET_assert (((heap->size == 1) &&
-                  (heap->root == NULL)) ||
+  GNUNET_assert (((heap->size == 1) && (heap->root == NULL)) ||
                  (heap->size == heap->root->tree_size + 2));
 #endif
   node->cost = new_cost;
@@ -542,8 +543,7 @@ GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_Heap *heap,
     insert_node (heap, heap->root, node);
 #if DEBUG
   CHECK (heap->root);
-  GNUNET_assert (((heap->size == 0) &&
-                  (heap->root == NULL)) ||
+  GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
                  (heap->size == heap->root->tree_size + 1));
 #endif
 }
diff --git a/src/util/container_meta_data.c b/src/util/container_meta_data.c
index 64a58e133..c67e96dac 100644
--- a/src/util/container_meta_data.c
+++ b/src/util/container_meta_data.c
@@ -224,8 +224,7 @@ GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
     j = md2->items;
     while (NULL != j)
     {
-      if ((i->type == j->type) &&
-          (i->format == j->format) &&
+      if ((i->type == j->type) && (i->format == j->format) &&
           (i->data_size == j->data_size) &&
           (0 == memcmp (i->data, j->data, i->data_size)))
       {
@@ -265,8 +264,8 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
                                    const char *plugin_name,
                                    enum EXTRACTOR_MetaType type,
                                    enum EXTRACTOR_MetaFormat format,
-                                   const char *data_mime_type,
-                                   const char *data, size_t data_len)
+                                   const char *data_mime_type, const char *data,
+                                   size_t data_len)
 {
   struct MetaItem *prev;
   struct MetaItem *pos;
@@ -279,8 +278,7 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
   {
     if (pos->data_size < data_len)
       break;
-    if ((pos->type == type) &&
-        (pos->data_size == data_len) &&
+    if ((pos->type == type) && (pos->data_size == data_len) &&
         (0 == memcmp (pos->data, data, data_len)))
     {
       if ((pos->mime_type == NULL) && (data_mime_type != NULL))
@@ -349,16 +347,13 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
  * @return 0 (to continue)
  */
 static int
-merge_helper (void *cls,
-              const char *plugin_name,
-              enum EXTRACTOR_MetaType type,
-              enum EXTRACTOR_MetaFormat format,
-              const char *data_mime_type, const char *data, size_t data_len)
+merge_helper (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
+              enum EXTRACTOR_MetaFormat format, const char *data_mime_type,
+              const char *data, size_t data_len)
 {
   struct GNUNET_CONTAINER_MetaData *md = cls;
 
-  (void) GNUNET_CONTAINER_meta_data_insert (md, plugin_name,
-                                            type, format,
+  (void) GNUNET_CONTAINER_meta_data_insert (md, plugin_name, type, format,
                                             data_mime_type, data, data_len);
   return 0;
 }
@@ -436,15 +431,13 @@ GNUNET_CONTAINER_meta_data_add_publication_date (struct
   struct GNUNET_TIME_Absolute t;
 
   t = GNUNET_TIME_absolute_get ();
-  GNUNET_CONTAINER_meta_data_delete (md,
-                                     EXTRACTOR_METATYPE_PUBLICATION_DATE,
+  GNUNET_CONTAINER_meta_data_delete (md, EXTRACTOR_METATYPE_PUBLICATION_DATE,
                                      NULL, 0);
   dat = GNUNET_STRINGS_absolute_time_to_string (t);
-  GNUNET_CONTAINER_meta_data_insert (md,
-                                     "<gnunet>",
+  GNUNET_CONTAINER_meta_data_insert (md, "<gnunet>",
                                      EXTRACTOR_METATYPE_PUBLICATION_DATE,
-                                     EXTRACTOR_METAFORMAT_UTF8,
-                                     "text/plain", dat, strlen (dat) + 1);
+                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                     dat, strlen (dat) + 1);
   GNUNET_free (dat);
 }
 
@@ -458,10 +451,9 @@ GNUNET_CONTAINER_meta_data_add_publication_date (struct
  * @return number of entries
  */
 int
-GNUNET_CONTAINER_meta_data_iterate (const struct
-                                    GNUNET_CONTAINER_MetaData *md,
-                                    EXTRACTOR_MetaDataProcessor
-                                    iter, void *iter_cls)
+GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData *md,
+                                    EXTRACTOR_MetaDataProcessor iter,
+                                    void *iter_cls)
 {
   struct MetaItem *pos;
 
@@ -472,10 +464,9 @@ GNUNET_CONTAINER_meta_data_iterate (const struct
   pos = md->items;
   while (NULL != pos)
   {
-    if (0 != iter (iter_cls,
-                   pos->plugin_name,
-                   pos->type,
-                   pos->format, pos->mime_type, pos->data, pos->data_size))
+    if (0 !=
+        iter (iter_cls, pos->plugin_name, pos->type, pos->format,
+              pos->mime_type, pos->data, pos->data_size))
       return md->item_count;
     pos = pos->next;
   }
@@ -562,9 +553,8 @@ GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
  * @return number of bytes in thumbnail, 0 if not available
  */
 size_t
-GNUNET_CONTAINER_meta_data_get_thumbnail (const struct
-                                          GNUNET_CONTAINER_MetaData * md,
-                                          unsigned char **thumb)
+GNUNET_CONTAINER_meta_data_get_thumbnail (const struct GNUNET_CONTAINER_MetaData
+                                          * md, unsigned char **thumb)
 {
   struct MetaItem *pos;
   struct MetaItem *match;
@@ -576,8 +566,7 @@ GNUNET_CONTAINER_meta_data_get_thumbnail (const struct
   while (NULL != pos)
   {
     if ((NULL != pos->mime_type) &&
-        (0 == strncasecmp ("image/", pos->mime_type,
-                           strlen ("image/"))) &&
+        (0 == strncasecmp ("image/", pos->mime_type, strlen ("image/"))) &&
         (pos->format == EXTRACTOR_METAFORMAT_BINARY))
     {
       if (match == NULL)
@@ -615,12 +604,9 @@ GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
   pos = md->items;
   while (NULL != pos)
   {
-    GNUNET_CONTAINER_meta_data_insert (ret,
-                                       pos->plugin_name,
-                                       pos->type,
-                                       pos->format,
-                                       pos->mime_type,
-                                       pos->data, pos->data_size);
+    GNUNET_CONTAINER_meta_data_insert (ret, pos->plugin_name, pos->type,
+                                       pos->format, pos->mime_type, pos->data,
+                                       pos->data_size);
     pos = pos->next;
   }
   return ret;
@@ -642,8 +628,8 @@ GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
  *         GNUNET_NO if compression did not help
  */
 static int
-try_compression (const char *data,
-                 size_t oldSize, char **result, size_t * newSize)
+try_compression (const char *data, size_t oldSize, char **result,
+                 size_t * newSize)
 {
   char *tmp;
   uLongf dlen;
@@ -656,8 +642,8 @@ try_compression (const char *data,
    * should be able to overshoot by more to be safe */
 #endif
   tmp = GNUNET_malloc (dlen);
-  if (Z_OK == compress2 ((Bytef *) tmp,
-                         &dlen, (const Bytef *) data, oldSize, 9))
+  if (Z_OK ==
+      compress2 ((Bytef *) tmp, &dlen, (const Bytef *) data, oldSize, 9))
   {
     if (dlen < oldSize)
     {
@@ -990,10 +976,9 @@ GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
   if (md->sbuf != NULL)
     return md->sbuf_size;
   ptr = NULL;
-  ret = GNUNET_CONTAINER_meta_data_serialize (md,
-                                              &ptr,
-                                              GNUNET_MAX_MALLOC_CHECKED,
-                                              GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  ret =
+      GNUNET_CONTAINER_meta_data_serialize (md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
+                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   if (ret != -1)
     GNUNET_free (ptr);
   return ret;
@@ -1018,8 +1003,8 @@ decompress (const char *input, size_t inputSize, size_t outputSize)
 
   olen = outputSize;
   output = GNUNET_malloc (olen);
-  if (Z_OK == uncompress ((Bytef *) output,
-                          &olen, (const Bytef *) input, inputSize))
+  if (Z_OK ==
+      uncompress ((Bytef *) output, &olen, (const Bytef *) input, inputSize))
   {
     return output;
   }
@@ -1119,8 +1104,7 @@ GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size)
   mdata = &cdata[ic * sizeof (struct MetaDataEntry)];
   for (i = 0; i < ic; i++)
   {
-    memcpy (&ent,
-            &cdata[i * sizeof (struct MetaDataEntry)],
+    memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)],
             sizeof (struct MetaDataEntry));
     format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format);
     if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
@@ -1180,11 +1164,10 @@ GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size)
       mime_type = NULL;
     else
       mime_type = &mdata[left];
-    GNUNET_CONTAINER_meta_data_insert (md,
-                                       plugin_name,
-                                       (enum EXTRACTOR_MetaType)
-                                       ntohl (ent.type), format, mime_type,
-                                       meta_data, dlen);
+    GNUNET_CONTAINER_meta_data_insert (md, plugin_name,
+                                       (enum EXTRACTOR_MetaType) ntohl (ent.
+                                                                        type),
+                                       format, mime_type, meta_data, dlen);
   }
   GNUNET_free_non_null (data);
   return md;
diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c
index 9635af17d..974d6c7f7 100644
--- a/src/util/container_multihashmap.c
+++ b/src/util/container_multihashmap.c
@@ -230,9 +230,8 @@ GNUNET_CONTAINER_multihashmap_iterate (const struct
  *  is not in the map
  */
 int
-GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap
-                                      *map, const GNUNET_HashCode * key,
-                                      void *value)
+GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
+                                      const GNUNET_HashCode * key, void *value)
 {
   struct MapEntry *e;
   struct MapEntry *p;
@@ -348,8 +347,7 @@ GNUNET_CONTAINER_multihashmap_contains (const struct
 int
 GNUNET_CONTAINER_multihashmap_contains_value (const struct
                                               GNUNET_CONTAINER_MultiHashMap
-                                              *map,
-                                              const GNUNET_HashCode * key,
+                                              *map, const GNUNET_HashCode * key,
                                               const void *value)
 {
   struct MapEntry *e;
@@ -416,8 +414,7 @@ grow (struct GNUNET_CONTAINER_MultiHashMap *map)
  */
 int
 GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
-                                   const GNUNET_HashCode * key,
-                                   void *value,
+                                   const GNUNET_HashCode * key, void *value,
                                    enum GNUNET_CONTAINER_MultiHashMapOption opt)
 {
   struct MapEntry *e;
@@ -467,10 +464,10 @@ GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
  */
 int
 GNUNET_CONTAINER_multihashmap_get_multiple (const struct
-                                            GNUNET_CONTAINER_MultiHashMap
-                                            *map, const GNUNET_HashCode * key,
-                                            GNUNET_CONTAINER_HashMapIterator
-                                            it, void *it_cls)
+                                            GNUNET_CONTAINER_MultiHashMap *map,
+                                            const GNUNET_HashCode * key,
+                                            GNUNET_CONTAINER_HashMapIterator it,
+                                            void *it_cls)
 {
   int count;
   struct MapEntry *e;
diff --git a/src/util/container_slist.c b/src/util/container_slist.c
index c06d70e91..2d7c24c03 100644
--- a/src/util/container_slist.c
+++ b/src/util/container_slist.c
@@ -107,8 +107,8 @@ struct GNUNET_CONTAINER_SList_Iterator
  * @return a new element
  */
 static struct GNUNET_CONTAINER_SList_Elem *
-create_elem (enum GNUNET_CONTAINER_SListDisposition disp,
-             const void *buf, size_t len)
+create_elem (enum GNUNET_CONTAINER_SListDisposition disp, const void *buf,
+             size_t len)
 {
   struct GNUNET_CONTAINER_SList_Elem *e;
 
@@ -186,8 +186,9 @@ GNUNET_CONTAINER_slist_append (struct GNUNET_CONTAINER_SList *dst,
 {
   struct GNUNET_CONTAINER_SList_Iterator *i;
 
-  for (i = GNUNET_CONTAINER_slist_begin (src); GNUNET_CONTAINER_slist_end (i) !=
-       GNUNET_YES; GNUNET_CONTAINER_slist_next (i))
+  for (i = GNUNET_CONTAINER_slist_begin (src);
+       GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;
+       GNUNET_CONTAINER_slist_next (i))
 
   {
     GNUNET_CONTAINER_slist_add (dst,
diff --git a/src/util/crypto_aes.c b/src/util/crypto_aes.c
index 200c367c1..a984e17fc 100644
--- a/src/util/crypto_aes.c
+++ b/src/util/crypto_aes.c
@@ -73,12 +73,11 @@ GNUNET_CRYPTO_aes_check_session_key (const struct GNUNET_CRYPTO_AesSessionKey
  * @returns the size of the encrypted block, -1 for errors
  */
 ssize_t
-GNUNET_CRYPTO_aes_encrypt (const void *block,
-                           size_t len,
-                           const struct GNUNET_CRYPTO_AesSessionKey
-                           * sessionkey,
-                           const struct GNUNET_CRYPTO_AesInitializationVector
-                           * iv, void *result)
+GNUNET_CRYPTO_aes_encrypt (const void *block, size_t len,
+                           const struct GNUNET_CRYPTO_AesSessionKey *
+                           sessionkey,
+                           const struct GNUNET_CRYPTO_AesInitializationVector *
+                           iv, void *result)
 {
   gcry_cipher_hd_t handle;
   int rc;
@@ -89,9 +88,9 @@ GNUNET_CRYPTO_aes_encrypt (const void *block,
     GNUNET_break (0);
     return -1;
   }
-  GNUNET_assert (0 == gcry_cipher_open (&handle,
-                                        GCRY_CIPHER_AES256,
-                                        GCRY_CIPHER_MODE_CFB, 0));
+  GNUNET_assert (0 ==
+                 gcry_cipher_open (&handle, GCRY_CIPHER_AES256,
+                                   GCRY_CIPHER_MODE_CFB, 0));
   rc = gcry_cipher_setkey (handle, sessionkey, GNUNET_CRYPTO_AES_KEY_LENGTH);
   GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
   rc = gcry_cipher_setiv (handle, iv,
@@ -115,12 +114,11 @@ GNUNET_CRYPTO_aes_encrypt (const void *block,
  * @return -1 on failure, size of decrypted block on success
  */
 ssize_t
-GNUNET_CRYPTO_aes_decrypt (const void *block,
-                           size_t size,
-                           const struct GNUNET_CRYPTO_AesSessionKey
-                           * sessionkey,
-                           const struct GNUNET_CRYPTO_AesInitializationVector
-                           * iv, void *result)
+GNUNET_CRYPTO_aes_decrypt (const void *block, size_t size,
+                           const struct GNUNET_CRYPTO_AesSessionKey *
+                           sessionkey,
+                           const struct GNUNET_CRYPTO_AesInitializationVector *
+                           iv, void *result)
 {
   gcry_cipher_hd_t handle;
   int rc;
@@ -131,9 +129,9 @@ GNUNET_CRYPTO_aes_decrypt (const void *block,
     GNUNET_break (0);
     return -1;
   }
-  GNUNET_assert (0 == gcry_cipher_open (&handle,
-                                        GCRY_CIPHER_AES256,
-                                        GCRY_CIPHER_MODE_CFB, 0));
+  GNUNET_assert (0 ==
+                 gcry_cipher_open (&handle, GCRY_CIPHER_AES256,
+                                   GCRY_CIPHER_MODE_CFB, 0));
   rc = gcry_cipher_setkey (handle, sessionkey, GNUNET_CRYPTO_AES_KEY_LENGTH);
   GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
   rc = gcry_cipher_setiv (handle, iv,
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index c693ed081..6438784ba 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -175,8 +175,7 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 struct GNUNET_CRYPTO_FileHashContext *
 GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
-                         const char *filename,
-                         size_t blocksize,
+                         const char *filename, size_t blocksize,
                          GNUNET_CRYPTO_HashCompletedCallback callback,
                          void *callback_cls)
 {
@@ -202,17 +201,17 @@ GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
     GNUNET_free (fhc);
     return NULL;
   }
-  fhc->fh = GNUNET_DISK_file_open (filename,
-                                   GNUNET_DISK_OPEN_READ,
-                                   GNUNET_DISK_PERM_NONE);
+  fhc->fh =
+      GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_NONE);
   if (!fhc->fh)
   {
     GNUNET_free (fhc->filename);
     GNUNET_free (fhc);
     return NULL;
   }
-  fhc->task
-      = GNUNET_SCHEDULER_add_with_priority (priority, &file_hash_task, fhc);
+  fhc->task =
+      GNUNET_SCHEDULER_add_with_priority (priority, &file_hash_task, fhc);
   return fhc;
 }
 
@@ -390,8 +389,8 @@ GNUNET_CRYPTO_hash_sum (const GNUNET_HashCode * a,
 
 
 void
-GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a,
-                        const GNUNET_HashCode * b, GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a, const GNUNET_HashCode * b,
+                        GNUNET_HashCode * result)
 {
   int i;
 
@@ -542,12 +541,11 @@ GNUNET_CRYPTO_hmac_derive_key (struct GNUNET_CRYPTO_AuthKey *key,
 void
 GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key,
                                  const struct GNUNET_CRYPTO_AesSessionKey *rkey,
-                                 const void *salt,
-                                 size_t salt_len, va_list argp)
+                                 const void *salt, size_t salt_len,
+                                 va_list argp)
 {
-  GNUNET_CRYPTO_kdf_v (key->key,
-                       sizeof (key->key),
-                       salt, salt_len, rkey->key, sizeof (rkey->key), argp);
+  GNUNET_CRYPTO_kdf_v (key->key, sizeof (key->key), salt, salt_len, rkey->key,
+                       sizeof (rkey->key), argp);
 }
 
 
@@ -561,15 +559,14 @@ GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key,
  */
 void
 GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
-                    const void *plaintext,
-                    size_t plaintext_len, GNUNET_HashCode * hmac)
+                    const void *plaintext, size_t plaintext_len,
+                    GNUNET_HashCode * hmac)
 {
   gcry_md_hd_t md;
   const unsigned char *mc;
 
-  GNUNET_assert (GPG_ERR_NO_ERROR == gcry_md_open (&md,
-                                                   GCRY_MD_SHA512,
-                                                   GCRY_MD_FLAG_HMAC));
+  GNUNET_assert (GPG_ERR_NO_ERROR ==
+                 gcry_md_open (&md, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC));
   gcry_md_setkey (md, key->key, sizeof (key->key));
   gcry_md_write (md, plaintext, plaintext_len);
   mc = gcry_md_read (md, GCRY_MD_SHA512);
diff --git a/src/util/crypto_hkdf.c b/src/util/crypto_hkdf.c
index d97f516fe..0654b51f6 100644
--- a/src/util/crypto_hkdf.c
+++ b/src/util/crypto_hkdf.c
@@ -71,8 +71,8 @@
  * @return HMAC, freed by caller via gcry_md_close/_reset
  */
 static const void *
-doHMAC (gcry_md_hd_t mac,
-        const void *key, size_t key_len, const void *buf, size_t buf_len)
+doHMAC (gcry_md_hd_t mac, const void *key, size_t key_len, const void *buf,
+        size_t buf_len)
 {
   gcry_md_setkey (mac, key, key_len);
   gcry_md_write (mac, buf, buf_len);
@@ -91,9 +91,8 @@ doHMAC (gcry_md_hd_t mac,
  * @return GNUNET_YES on success
  */
 static int
-getPRK (gcry_md_hd_t mac,
-        const void *xts, size_t xts_len,
-        const void *skm, size_t skm_len, void *prk)
+getPRK (gcry_md_hd_t mac, const void *xts, size_t xts_len, const void *skm,
+        size_t skm_len, void *prk)
 {
   const void *ret;
 
@@ -136,10 +135,9 @@ dump (const char *src, const void *p, unsigned int l)
  * @return GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len,
-                      int xtr_algo, int prf_algo,
-                      const void *xts, size_t xts_len,
-                      const void *skm, size_t skm_len, va_list argp)
+GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo,
+                      const void *xts, size_t xts_len, const void *skm,
+                      size_t skm_len, va_list argp)
 {
   const void *hc;
   unsigned long i, t, d;
@@ -280,17 +278,17 @@ hkdf_ok:
  * @return GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_hkdf (void *result, size_t out_len,
-                    int xtr_algo, int prf_algo,
-                    const void *xts, size_t xts_len,
-                    const void *skm, size_t skm_len, ...)
+GNUNET_CRYPTO_hkdf (void *result, size_t out_len, int xtr_algo, int prf_algo,
+                    const void *xts, size_t xts_len, const void *skm,
+                    size_t skm_len, ...)
 {
   va_list argp;
   int ret;
 
   va_start (argp, skm_len);
-  ret = GNUNET_CRYPTO_hkdf_v (result, out_len, xtr_algo, prf_algo, xts,
-                              xts_len, skm, skm_len, argp);
+  ret =
+      GNUNET_CRYPTO_hkdf_v (result, out_len, xtr_algo, prf_algo, xts, xts_len,
+                            skm, skm_len, argp);
   va_end (argp);
 
   return ret;
diff --git a/src/util/crypto_kdf.c b/src/util/crypto_kdf.c
index dc2e667af..cd665ad23 100644
--- a/src/util/crypto_kdf.c
+++ b/src/util/crypto_kdf.c
@@ -41,9 +41,9 @@
  * @return GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_kdf_v (void *result, size_t out_len,
-                     const void *xts, size_t xts_len, const void *skm,
-                     size_t skm_len, va_list argp)
+GNUNET_CRYPTO_kdf_v (void *result, size_t out_len, const void *xts,
+                     size_t xts_len, const void *skm, size_t skm_len,
+                     va_list argp)
 {
   /*
    * "Finally, we point out to a particularly advantageous instantiation using
@@ -73,9 +73,8 @@ GNUNET_CRYPTO_kdf_v (void *result, size_t out_len,
  * @return GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_kdf (void *result, size_t out_len,
-                   const void *xts, size_t xts_len, const void *skm,
-                   size_t skm_len, ...)
+GNUNET_CRYPTO_kdf (void *result, size_t out_len, const void *xts,
+                   size_t xts_len, const void *skm, size_t skm_len, ...)
 {
   va_list argp;
   int ret;
diff --git a/src/util/crypto_ksk.c b/src/util/crypto_ksk.c
index 7c23fc1e0..bec87c803 100644
--- a/src/util/crypto_ksk.c
+++ b/src/util/crypto_ksk.c
@@ -397,8 +397,8 @@ gen_prime (gcry_mpi_t * ptest, unsigned int nbits, GNUNET_HashCode * hc)
  * @param hc the HC to use for PRNG (modified!)
  */
 static void
-generate_kblock_key (KBlock_secret_key *sk,
-                     unsigned int nbits, GNUNET_HashCode * hc)
+generate_kblock_key (KBlock_secret_key *sk, unsigned int nbits,
+                     GNUNET_HashCode * hc)
 {
   gcry_mpi_t t1, t2;
   gcry_mpi_t phi;               /* helper: (p-1)(q-1) */
@@ -569,10 +569,9 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
 
   pos = 0;
   size = ntohs (encoding->sizen);
-  rc = gcry_mpi_scan (&n,
-                      GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos],
-                      size, &size);
+  rc = gcry_mpi_scan (&n, GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sizen);
   if (rc)
   {
@@ -580,10 +579,9 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
     return NULL;
   }
   size = ntohs (encoding->sizee);
-  rc = gcry_mpi_scan (&e,
-                      GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos],
-                      size, &size);
+  rc = gcry_mpi_scan (&e, GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sizee);
   if (rc)
   {
@@ -592,10 +590,9 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
     return NULL;
   }
   size = ntohs (encoding->sized);
-  rc = gcry_mpi_scan (&d,
-                      GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos],
-                      size, &size);
+  rc = gcry_mpi_scan (&d, GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sized);
   if (rc)
   {
@@ -608,10 +605,9 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
   size = ntohs (encoding->sizep);
   if (size > 0)
   {
-    rc = gcry_mpi_scan (&q,
-                        GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos],
-                        size, &size);
+    rc = gcry_mpi_scan (&q, GCRYMPI_FMT_USG,
+                        &((const unsigned char *) (&encoding[1]))[pos], size,
+                        &size);
     pos += ntohs (encoding->sizep);
     if (rc)
     {
@@ -627,10 +623,9 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
   size = ntohs (encoding->sizeq);
   if (size > 0)
   {
-    rc = gcry_mpi_scan (&p,
-                        GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos],
-                        size, &size);
+    rc = gcry_mpi_scan (&p, GCRYMPI_FMT_USG,
+                        &((const unsigned char *) (&encoding[1]))[pos], size,
+                        &size);
     pos += ntohs (encoding->sizeq);
     if (rc)
     {
@@ -652,10 +647,9 @@ ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
       pos;
   if (size > 0)
   {
-    rc = gcry_mpi_scan (&u,
-                        GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos],
-                        size, &size);
+    rc = gcry_mpi_scan (&u, GCRYMPI_FMT_USG,
+                        &((const unsigned char *) (&encoding[1]))[pos], size,
+                        &size);
     if (rc)
     {
       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
diff --git a/src/util/crypto_random.c b/src/util/crypto_random.c
index 03f6c0e98..bb105437d 100644
--- a/src/util/crypto_random.c
+++ b/src/util/crypto_random.c
@@ -71,8 +71,8 @@ GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i)
     ul = UINT32_MAX - (UINT32_MAX % i);
     do
     {
-      gcry_randomize ((unsigned char *) &ret,
-                      sizeof (uint32_t), GCRY_STRONG_RANDOM);
+      gcry_randomize ((unsigned char *) &ret, sizeof (uint32_t),
+                      GCRY_STRONG_RANDOM);
     }
     while (ret >= ul);
     return ret % i;
@@ -147,8 +147,8 @@ GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode, uint64_t max)
     ul = UINT64_MAX - (UINT64_MAX % max);
     do
     {
-      gcry_randomize ((unsigned char *) &ret,
-                      sizeof (uint64_t), GCRY_STRONG_RANDOM);
+      gcry_randomize ((unsigned char *) &ret, sizeof (uint64_t),
+                      GCRY_STRONG_RANDOM);
     }
     while (ret >= ul);
     return ret % max;
@@ -195,8 +195,8 @@ static struct GNUNET_OS_Process *genproc;
  * blocked gathering entropy.
  */
 static void
-entropy_generator (void *cls,
-                   const char *what, int printchar, int current, int total)
+entropy_generator (void *cls, const char *what, int printchar, int current,
+                   int total)
 {
   unsigned long code;
   enum GNUNET_OS_ProcessStatusType type;
@@ -234,11 +234,10 @@ entropy_generator (void *cls,
   }
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _("Starting `%s' process to generate entropy\n"), "find");
-  genproc = GNUNET_OS_start_process (NULL, NULL, "sh",
-                                     "sh",
-                                     "-c",
-                                     "exec find / -mount -type f -exec cp {} /dev/null \\; 2>/dev/null",
-                                     NULL);
+  genproc =
+      GNUNET_OS_start_process (NULL, NULL, "sh", "sh", "-c",
+                               "exec find / -mount -type f -exec cp {} /dev/null \\; 2>/dev/null",
+                               NULL);
 }
 
 
diff --git a/src/util/crypto_rsa.c b/src/util/crypto_rsa.c
index 6be2f53c0..3607998e4 100644
--- a/src/util/crypto_rsa.c
+++ b/src/util/crypto_rsa.c
@@ -108,10 +108,10 @@ GNUNET_CRYPTO_rsa_key_create ()
   gcry_sexp_t s_key;
   gcry_sexp_t s_keyparam;
 
-  GNUNET_assert (0 == gcry_sexp_build (&s_keyparam,
-                                       NULL,
-                                       "(genkey(rsa(nbits %d)(rsa-use-e 3:257)))",
-                                       HOSTKEY_LEN));
+  GNUNET_assert (0 ==
+                 gcry_sexp_build (&s_keyparam, NULL,
+                                  "(genkey(rsa(nbits %d)(rsa-use-e 3:257)))",
+                                  HOSTKEY_LEN));
   GNUNET_assert (0 == gcry_pk_genkey (&s_key, s_keyparam));
   gcry_sexp_release (s_keyparam);
 #if EXTRA_CHECKS
@@ -133,8 +133,8 @@ GNUNET_CRYPTO_rsa_key_free (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
 }
 
 static int
-key_from_sexp (gcry_mpi_t * array,
-               gcry_sexp_t sexp, const char *topname, const char *elems)
+key_from_sexp (gcry_mpi_t * array, gcry_sexp_t sexp, const char *topname,
+               const char *elems)
 {
   gcry_sexp_t list, l2;
   const char *s;
@@ -192,8 +192,8 @@ key_from_sexp (gcry_mpi_t * array,
 void
 GNUNET_CRYPTO_rsa_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateKey
                                   *priv,
-                                  struct
-                                  GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pub)
+                                  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                                  *pub)
 {
   gcry_mpi_t skey[2];
   size_t size;
@@ -211,14 +211,15 @@ GNUNET_CRYPTO_rsa_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateKey
   pub->sizen = htons (GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
   pub->padding = 0;
   size = GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
-  GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
-                                      &pub->key[0], size, &size, skey[0]));
+  GNUNET_assert (0 ==
+                 gcry_mpi_print (GCRYMPI_FMT_USG, &pub->key[0], size, &size,
+                                 skey[0]));
   adjust (&pub->key[0], size, GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
   size = GNUNET_CRYPTO_RSA_KEY_LENGTH - GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
   GNUNET_assert (0 ==
                  gcry_mpi_print (GCRYMPI_FMT_USG,
-                                 &pub->key
-                                 [GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH],
+                                 &pub->
+                                 key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH],
                                  size, &size, skey[1]));
   adjust (&pub->key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH], size,
           GNUNET_CRYPTO_RSA_KEY_LENGTH -
@@ -271,8 +272,8 @@ public2PrivateKey (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
     gcry_mpi_release (n);
     return NULL;
   }
-  rc = gcry_sexp_build (&result,
-                        &erroff, "(public-key(rsa(n %m)(e %m)))", n, e);
+  rc = gcry_sexp_build (&result, &erroff, "(public-key(rsa(n %m)(e %m)))", n,
+                        e);
   gcry_mpi_release (n);
   gcry_mpi_release (e);
   if (rc)
@@ -329,9 +330,10 @@ rsa_encode_key (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
   {
     if (pkv[i] != NULL)
     {
-      GNUNET_assert (0 == gcry_mpi_aprint (GCRYMPI_FMT_USG,
-                                           (unsigned char **) &pbu[i],
-                                           &sizes[i], pkv[i]));
+      GNUNET_assert (0 ==
+                     gcry_mpi_aprint (GCRYMPI_FMT_USG,
+                                      (unsigned char **) &pbu[i], &sizes[i],
+                                      pkv[i]));
       size += sizes[i];
     }
     else
@@ -399,10 +401,9 @@ GNUNET_CRYPTO_rsa_decode_key (const char *buf, uint16_t len)
 
   pos = 0;
   size = ntohs (encoding->sizen);
-  rc = gcry_mpi_scan (&n,
-                      GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos],
-                      size, &size);
+  rc = gcry_mpi_scan (&n, GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sizen);
   if (rc)
   {
@@ -410,10 +411,9 @@ GNUNET_CRYPTO_rsa_decode_key (const char *buf, uint16_t len)
     return NULL;
   }
   size = ntohs (encoding->sizee);
-  rc = gcry_mpi_scan (&e,
-                      GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos],
-                      size, &size);
+  rc = gcry_mpi_scan (&e, GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sizee);
   if (rc)
   {
@@ -422,10 +422,9 @@ GNUNET_CRYPTO_rsa_decode_key (const char *buf, uint16_t len)
     return NULL;
   }
   size = ntohs (encoding->sized);
-  rc = gcry_mpi_scan (&d,
-                      GCRYMPI_FMT_USG,
-                      &((const unsigned char *) (&encoding[1]))[pos],
-                      size, &size);
+  rc = gcry_mpi_scan (&d, GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos], size,
+                      &size);
   pos += ntohs (encoding->sized);
   if (rc)
   {
@@ -438,10 +437,9 @@ GNUNET_CRYPTO_rsa_decode_key (const char *buf, uint16_t len)
   size = ntohs (encoding->sizep);
   if (size > 0)
   {
-    rc = gcry_mpi_scan (&q,
-                        GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos],
-                        size, &size);
+    rc = gcry_mpi_scan (&q, GCRYMPI_FMT_USG,
+                        &((const unsigned char *) (&encoding[1]))[pos], size,
+                        &size);
     pos += ntohs (encoding->sizep);
     if (rc)
     {
@@ -457,10 +455,9 @@ GNUNET_CRYPTO_rsa_decode_key (const char *buf, uint16_t len)
   size = ntohs (encoding->sizeq);
   if (size > 0)
   {
-    rc = gcry_mpi_scan (&p,
-                        GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos],
-                        size, &size);
+    rc = gcry_mpi_scan (&p, GCRYMPI_FMT_USG,
+                        &((const unsigned char *) (&encoding[1]))[pos], size,
+                        &size);
     pos += ntohs (encoding->sizeq);
     if (rc)
     {
@@ -481,10 +478,9 @@ GNUNET_CRYPTO_rsa_decode_key (const char *buf, uint16_t len)
       ntohs (encoding->len) - sizeof (struct RsaPrivateKeyBinaryEncoded) - pos;
   if (size > 0)
   {
-    rc = gcry_mpi_scan (&u,
-                        GCRYMPI_FMT_USG,
-                        &((const unsigned char *) (&encoding[1]))[pos],
-                        size, &size);
+    rc = gcry_mpi_scan (&u, GCRYMPI_FMT_USG,
+                        &((const unsigned char *) (&encoding[1]))[pos], size,
+                        &size);
     if (rc)
     {
       LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
@@ -577,9 +573,8 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
   while (GNUNET_YES != GNUNET_DISK_file_test (filename))
   {
     fd = GNUNET_DISK_file_open (filename,
-                                GNUNET_DISK_OPEN_WRITE |
-                                GNUNET_DISK_OPEN_CREATE |
-                                GNUNET_DISK_OPEN_FAILIFEXISTS,
+                                GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
+                                | GNUNET_DISK_OPEN_FAILIFEXISTS,
                                 GNUNET_DISK_PERM_USER_READ |
                                 GNUNET_DISK_PERM_USER_WRITE);
     if (NULL == fd)
@@ -590,8 +585,8 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
         {
           /* must exist but not be accessible, fail for good! */
           if (0 != ACCESS (filename, R_OK))
-            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
-                                      "access", filename);
+            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "access",
+                                      filename);
           else
             GNUNET_break (0);   /* what is going on!? */
           return NULL;
@@ -605,8 +600,7 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
 
     while (GNUNET_YES !=
            GNUNET_DISK_file_lock (fd, 0,
-                                  sizeof (struct
-                                          RsaPrivateKeyBinaryEncoded),
+                                  sizeof (struct RsaPrivateKeyBinaryEncoded),
                                   GNUNET_YES))
     {
       sleep (1);
@@ -614,9 +608,8 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
       {
         ec = errno;
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _
-                    ("Could not aquire lock on file `%s': %s...\n"),
-                    filename, STRERROR (ec));
+                    _("Could not aquire lock on file `%s': %s...\n"), filename,
+                    STRERROR (ec));
       }
     }
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
@@ -662,8 +655,8 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
       {
         ec = errno;
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _("Could not aquire lock on file `%s': %s...\n"),
-                    filename, STRERROR (ec));
+                    _("Could not aquire lock on file `%s': %s...\n"), filename,
+                    STRERROR (ec));
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     _
                     ("This may be ok if someone is currently generating a hostkey.\n"));
@@ -754,10 +747,9 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
  * @returns GNUNET_SYSERR on error, GNUNET_OK if ok
  */
 int
-GNUNET_CRYPTO_rsa_encrypt (const void *block,
-                           size_t size,
-                           const struct
-                           GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey,
+GNUNET_CRYPTO_rsa_encrypt (const void *block, size_t size,
+                           const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                           *publicKey,
                            struct GNUNET_CRYPTO_RsaEncryptedData *target)
 {
   gcry_sexp_t result;
@@ -786,9 +778,9 @@ GNUNET_CRYPTO_rsa_encrypt (const void *block,
   GNUNET_assert (0 == key_from_sexp (&rval, result, "rsa", "a"));
   gcry_sexp_release (result);
   isize = sizeof (struct GNUNET_CRYPTO_RsaEncryptedData);
-  GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
-                                      (unsigned char *) target, isize, &isize,
-                                      rval));
+  GNUNET_assert (0 ==
+                 gcry_mpi_print (GCRYMPI_FMT_USG, (unsigned char *) target,
+                                 isize, &isize, rval));
   gcry_mpi_release (rval);
   adjust (&target->encoding[0], isize,
           sizeof (struct GNUNET_CRYPTO_RsaEncryptedData));
@@ -807,8 +799,8 @@ GNUNET_CRYPTO_rsa_encrypt (const void *block,
  */
 ssize_t
 GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey * key,
-                           const struct GNUNET_CRYPTO_RsaEncryptedData *
-                           block, void *result, size_t max)
+                           const struct GNUNET_CRYPTO_RsaEncryptedData * block,
+                           void *result, size_t max)
 {
   gcry_sexp_t resultsexp;
   gcry_sexp_t data;
@@ -822,12 +814,12 @@ GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey * key,
   GNUNET_assert (0 == gcry_pk_testkey (key->sexp));
 #endif
   size = sizeof (struct GNUNET_CRYPTO_RsaEncryptedData);
-  GNUNET_assert (0 == gcry_mpi_scan (&val,
-                                     GCRYMPI_FMT_USG, &block->encoding[0],
-                                     size, &size));
   GNUNET_assert (0 ==
-                 gcry_sexp_build (&data, &erroff,
-                                  "(enc-val(flags)(rsa(a %m)))", val));
+                 gcry_mpi_scan (&val, GCRYMPI_FMT_USG, &block->encoding[0],
+                                size, &size));
+  GNUNET_assert (0 ==
+                 gcry_sexp_build (&data, &erroff, "(enc-val(flags)(rsa(a %m)))",
+                                  val));
   gcry_mpi_release (val);
   GNUNET_assert (0 == gcry_pk_decrypt (&resultsexp, data, key->sexp));
   gcry_sexp_release (data);
@@ -858,8 +850,8 @@ GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey * key,
  */
 int
 GNUNET_CRYPTO_rsa_sign (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
-                        const struct GNUNET_CRYPTO_RsaSignaturePurpose
-                        *purpose, struct GNUNET_CRYPTO_RsaSignature *sig)
+                        const struct GNUNET_CRYPTO_RsaSignaturePurpose *purpose,
+                        struct GNUNET_CRYPTO_RsaSignature *sig)
 {
   gcry_sexp_t result;
   gcry_sexp_t data;
@@ -886,9 +878,9 @@ GNUNET_CRYPTO_rsa_sign (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
   GNUNET_assert (0 == key_from_sexp (&rval, result, "rsa", "s"));
   gcry_sexp_release (result);
   ssize = sizeof (struct GNUNET_CRYPTO_RsaSignature);
-  GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
-                                      (unsigned char *) sig, ssize, &ssize,
-                                      rval));
+  GNUNET_assert (0 ==
+                 gcry_mpi_print (GCRYMPI_FMT_USG, (unsigned char *) sig, ssize,
+                                 &ssize, rval));
   gcry_mpi_release (rval);
   adjust (sig->sig, ssize, sizeof (struct GNUNET_CRYPTO_RsaSignature));
   return GNUNET_OK;
@@ -927,9 +919,9 @@ GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
     return GNUNET_SYSERR;       /* purpose mismatch */
   GNUNET_CRYPTO_hash (validate, ntohl (validate->size), &hc);
   size = sizeof (struct GNUNET_CRYPTO_RsaSignature);
-  GNUNET_assert (0 == gcry_mpi_scan (&val,
-                                     GCRYMPI_FMT_USG,
-                                     (const unsigned char *) sig, size, &size));
+  GNUNET_assert (0 ==
+                 gcry_mpi_scan (&val, GCRYMPI_FMT_USG,
+                                (const unsigned char *) sig, size, &size));
   GNUNET_assert (0 ==
                  gcry_sexp_build (&sigdata, &erroff, "(sig-val(rsa(s %m)))",
                                   val));
@@ -937,9 +929,10 @@ GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
   bufSize = strlen (FORMATSTRING) + 1;
   buff = GNUNET_malloc (bufSize);
   memcpy (buff, FORMATSTRING, bufSize);
-  memcpy (&buff[strlen (FORMATSTRING) -
-                strlen
-                ("0123456789012345678901234567890123456789012345678901234567890123))")],
+  memcpy (&buff
+          [strlen (FORMATSTRING) -
+           strlen
+           ("0123456789012345678901234567890123456789012345678901234567890123))")],
           &hc, sizeof (GNUNET_HashCode));
   GNUNET_assert (0 == gcry_sexp_new (&data, buff, bufSize, 0));
   GNUNET_free (buff);
@@ -957,8 +950,8 @@ GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
   if (rc)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("RSA signature verification failed at %s:%d: %s\n"),
-                __FILE__, __LINE__, gcry_strerror (rc));
+                _("RSA signature verification failed at %s:%d: %s\n"), __FILE__,
+                __LINE__, gcry_strerror (rc));
     return GNUNET_SYSERR;
   }
   return GNUNET_OK;
diff --git a/src/util/disk.c b/src/util/disk.c
index dd7db7d73..6ba5db773 100644
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -172,8 +172,7 @@ getSizeRec (void *cls, const char *fn)
 #endif
   if ((!S_ISLNK (buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES))
     gfsd->total += buf.st_size;
-  if ((S_ISDIR (buf.st_mode)) &&
-      (0 == ACCESS (fn, X_OK)) &&
+  if ((S_ISDIR (buf.st_mode)) && (0 == ACCESS (fn, X_OK)) &&
       ((!S_ISLNK (buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES)))
   {
     if (GNUNET_SYSERR == GNUNET_DISK_directory_scan (fn, &getSizeRec, gfsd))
@@ -255,8 +254,8 @@ GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle * h, off_t offset,
  * @return GNUNET_SYSERR on error, GNUNET_OK on success
  */
 int
-GNUNET_DISK_file_size (const char *filename,
-                       uint64_t * size, int includeSymLinks)
+GNUNET_DISK_file_size (const char *filename, uint64_t * size,
+                       int includeSymLinks)
 {
   struct GetFileSizeData gfsd;
   int ret;
@@ -286,8 +285,8 @@ GNUNET_DISK_file_size (const char *filename,
  * @return GNUNET_OK on success
  */
 int
-GNUNET_DISK_file_get_identifiers (const char *filename,
-                                  uint64_t * dev, uint64_t * ino)
+GNUNET_DISK_file_get_identifiers (const char *filename, uint64_t * dev,
+                                  uint64_t * ino)
 {
 #if LINUX
   struct stat sbuf;
@@ -427,8 +426,8 @@ GNUNET_DISK_get_blocks_available (const char *part)
   if (!GetDiskFreeSpace (szDrive, &dwDummy, &dwDummy, &dwBlocks, &dwDummy))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("`%s' failed for drive `%s': %u\n"),
-                "GetDiskFreeSpace", szDrive, GetLastError ());
+                _("`%s' failed for drive `%s': %u\n"), "GetDiskFreeSpace",
+                szDrive, GetLastError ());
 
     return -1;
   }
@@ -772,15 +771,14 @@ GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
  * @return number of bytes written on success, GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_fn_write (const char *fn, const void *buffer,
-                      size_t n, enum GNUNET_DISK_AccessPermissions mode)
+GNUNET_DISK_fn_write (const char *fn, const void *buffer, size_t n,
+                      enum GNUNET_DISK_AccessPermissions mode)
 {
   struct GNUNET_DISK_FileHandle *fh;
   ssize_t ret;
 
   fh = GNUNET_DISK_file_open (fn,
-                              GNUNET_DISK_OPEN_WRITE
-                              | GNUNET_DISK_OPEN_TRUNCATE
+                              GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE
                               | GNUNET_DISK_OPEN_CREATE, mode);
   if (!fh)
     return GNUNET_SYSERR;
@@ -862,10 +860,7 @@ GNUNET_DISK_directory_scan (const char *dirName,
       /* dname can end in "/" only if dname == "/";
        * if dname does not end in "/", we need to add
        * a "/" (otherwise, we must not!) */
-      GNUNET_snprintf (name,
-                       n_size,
-                       "%s%s%s",
-                       dname,
+      GNUNET_snprintf (name, n_size, "%s%s%s", dname,
                        (strcmp (dname, DIR_SEPARATOR_STR) ==
                         0) ? "" : DIR_SEPARATOR_STR, finfo->d_name);
       if (GNUNET_OK != callback (callback_cls, name))
@@ -954,8 +949,8 @@ directory_iterator_task (void *cls,
  *         GNUNET_SYSERR if abort was YES
  */
 int
-GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator
-                                     *iter, int can)
+GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator *iter,
+                                     int can)
 {
   struct dirent *finfo;
 
@@ -972,8 +967,8 @@ GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator
     if ((0 == strcmp (finfo->d_name, ".")) ||
         (0 == strcmp (finfo->d_name, "..")))
       continue;
-    GNUNET_asprintf (&iter->next_name,
-                     "%s%s%s", iter->dirname, DIR_SEPARATOR_STR, finfo->d_name);
+    GNUNET_asprintf (&iter->next_name, "%s%s%s", iter->dirname,
+                     DIR_SEPARATOR_STR, finfo->d_name);
     break;
   }
   if (finfo == NULL)
@@ -981,8 +976,8 @@ GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator
     GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES);
     return GNUNET_NO;
   }
-  GNUNET_SCHEDULER_add_with_priority (iter->priority,
-                                      &directory_iterator_task, iter);
+  GNUNET_SCHEDULER_add_with_priority (iter->priority, &directory_iterator_task,
+                                      iter);
   return GNUNET_YES;
 }
 
@@ -1101,13 +1096,14 @@ GNUNET_DISK_file_copy (const char *src, const char *dst)
                               GNUNET_DISK_PERM_NONE);
   if (!in)
     return GNUNET_SYSERR;
-  out = GNUNET_DISK_file_open (dst, GNUNET_DISK_OPEN_WRITE
-                               | GNUNET_DISK_OPEN_CREATE |
-                               GNUNET_DISK_OPEN_FAILIFEXISTS,
-                               GNUNET_DISK_PERM_USER_READ |
-                               GNUNET_DISK_PERM_USER_WRITE |
-                               GNUNET_DISK_PERM_GROUP_READ |
-                               GNUNET_DISK_PERM_GROUP_WRITE);
+  out =
+      GNUNET_DISK_file_open (dst,
+                             GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
+                             GNUNET_DISK_OPEN_FAILIFEXISTS,
+                             GNUNET_DISK_PERM_USER_READ |
+                             GNUNET_DISK_PERM_USER_WRITE |
+                             GNUNET_DISK_PERM_GROUP_READ |
+                             GNUNET_DISK_PERM_GROUP_WRITE);
   if (!out)
   {
     GNUNET_DISK_file_close (in);
@@ -1152,8 +1148,8 @@ GNUNET_DISK_filename_canonicalize (char *fn)
   {
     c = *idx;
 
-    if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' ||
-        c == '"' || c == '<' || c == '>' || c == '|')
+    if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' ||
+        c == '<' || c == '>' || c == '|')
     {
       *idx = '_';
     }
@@ -1181,8 +1177,8 @@ GNUNET_DISK_file_change_owner (const char *filename, const char *user)
   if (pws == NULL)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Cannot obtain information about user `%s': %s\n"),
-                user, STRERROR (errno));
+                _("Cannot obtain information about user `%s': %s\n"), user,
+                STRERROR (errno));
     return GNUNET_SYSERR;
   }
   if (0 != chown (filename, pws->pw_uid, pws->pw_gid))
@@ -1226,8 +1222,9 @@ GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh, off_t lockStart,
   memset (&o, 0, sizeof (OVERLAPPED));
   o.Offset = lockStart;
 
-  if (!LockFileEx (fh->h, (excl ? LOCKFILE_EXCLUSIVE_LOCK : 0)
-                   | LOCKFILE_FAIL_IMMEDIATELY, 0, lockEnd - lockStart, 0, &o))
+  if (!LockFileEx
+      (fh->h, (excl ? LOCKFILE_EXCLUSIVE_LOCK : 0) | LOCKFILE_FAIL_IMMEDIATELY,
+       0, lockEnd - lockStart, 0, &o))
   {
     SetErrnoFromWinError (GetLastError ());
     return GNUNET_SYSERR;
@@ -1295,8 +1292,7 @@ GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, off_t unlockStart,
  * @return IO handle on success, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_file_open (const char *fn,
-                       enum GNUNET_DISK_OpenFlags flags,
+GNUNET_DISK_file_open (const char *fn, enum GNUNET_DISK_OpenFlags flags,
                        enum GNUNET_DISK_AccessPermissions perm)
 {
   char *expfn;
@@ -1385,8 +1381,9 @@ GNUNET_DISK_file_open (const char *fn,
   }
 
   /* TODO: access priviledges? */
-  h = CreateFile (expfn, access, FILE_SHARE_DELETE | FILE_SHARE_READ
-                  | FILE_SHARE_WRITE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
+  h = CreateFile (expfn, access,
+                  FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                  disp, FILE_ATTRIBUTE_NORMAL, NULL);
   if (h == INVALID_HANDLE_VALUE)
   {
     SetErrnoFromWinError (GetLastError ());
@@ -1713,10 +1710,9 @@ GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
    Note that the return value is either NO_ERROR or GetLastError,
    unlike CreatePipe, which returns a bool for success or failure.  */
 static int
-create_selectable_pipe (PHANDLE read_pipe_ptr,
-                        PHANDLE write_pipe_ptr,
-                        LPSECURITY_ATTRIBUTES sa_ptr,
-                        DWORD psize, DWORD dwReadMode, DWORD dwWriteMode)
+create_selectable_pipe (PHANDLE read_pipe_ptr, PHANDLE write_pipe_ptr,
+                        LPSECURITY_ATTRIBUTES sa_ptr, DWORD psize,
+                        DWORD dwReadMode, DWORD dwWriteMode)
 {
   /* Default to error. */
   *read_pipe_ptr = *write_pipe_ptr = INVALID_HANDLE_VALUE;
@@ -1921,10 +1917,9 @@ GNUNET_DISK_pipe (int blocking, int inherit_read, int inherit_write)
     SetErrnoFromWinError (GetLastError ());
     return NULL;
   }
-  if (!DuplicateHandle (GetCurrentProcess (), p->fd[0]->h,
-                        GetCurrentProcess (), &tmp_handle, 0,
-                        inherit_read == GNUNET_YES ? TRUE : FALSE,
-                        DUPLICATE_SAME_ACCESS))
+  if (!DuplicateHandle
+      (GetCurrentProcess (), p->fd[0]->h, GetCurrentProcess (), &tmp_handle, 0,
+       inherit_read == GNUNET_YES ? TRUE : FALSE, DUPLICATE_SAME_ACCESS))
   {
     SetErrnoFromWinError (GetLastError ());
     CloseHandle (p->fd[0]->h);
@@ -1935,10 +1930,9 @@ GNUNET_DISK_pipe (int blocking, int inherit_read, int inherit_write)
   CloseHandle (p->fd[0]->h);
   p->fd[0]->h = tmp_handle;
 
-  if (!DuplicateHandle (GetCurrentProcess (), p->fd[1]->h,
-                        GetCurrentProcess (), &tmp_handle, 0,
-                        inherit_write == GNUNET_YES ? TRUE : FALSE,
-                        DUPLICATE_SAME_ACCESS))
+  if (!DuplicateHandle
+      (GetCurrentProcess (), p->fd[1]->h, GetCurrentProcess (), &tmp_handle, 0,
+       inherit_write == GNUNET_YES ? TRUE : FALSE, DUPLICATE_SAME_ACCESS))
   {
     SetErrnoFromWinError (GetLastError ());
     CloseHandle (p->fd[0]->h);
@@ -2093,8 +2087,7 @@ GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
  * @return pipe handle on success, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_npipe_create (char **fn,
-                          enum GNUNET_DISK_OpenFlags flags,
+GNUNET_DISK_npipe_create (char **fn, enum GNUNET_DISK_OpenFlags flags,
                           enum GNUNET_DISK_AccessPermissions perm)
 {
 #ifdef MINGW
@@ -2226,8 +2219,7 @@ GNUNET_DISK_npipe_create (char **fn,
  * @return pipe handle on success, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_npipe_open (const char *fn,
-                        enum GNUNET_DISK_OpenFlags flags,
+GNUNET_DISK_npipe_open (const char *fn, enum GNUNET_DISK_OpenFlags flags,
                         enum GNUNET_DISK_AccessPermissions perm)
 {
 #ifdef MINGW
diff --git a/src/util/getopt.c b/src/util/getopt.c
index 2a35ab278..db81d1c3d 100644
--- a/src/util/getopt.c
+++ b/src/util/getopt.c
@@ -410,8 +410,8 @@ _getopt_initialize (argc, argv, optstring)
   {
     if (nonoption_flags_max_len == 0)
     {
-      if (__getopt_nonoption_flags == NULL
-          || __getopt_nonoption_flags[0] == '\0')
+      if (__getopt_nonoption_flags == NULL ||
+          __getopt_nonoption_flags[0] == '\0')
         nonoption_flags_max_len = -1;
       else
       {
@@ -497,11 +497,9 @@ _getopt_initialize (argc, argv, optstring)
    long-named options.  */
 
 static int
-GN_getopt_internal (int argc,
-                    char *const *argv,
-                    const char *optstring,
-                    const struct GNoption *longopts,
-                    int *longind, int long_only)
+GN_getopt_internal (int argc, char *const *argv, const char *optstring,
+                    const struct GNoption *longopts, int *longind,
+                    int long_only)
 {
   static int __getopt_initialized = 0;
   static int GNopterr = 1;
@@ -600,8 +598,8 @@ GN_getopt_internal (int argc,
     /* We have found another option-ARGV-element.
      * Skip the initial punctuation.  */
 
-    nextchar = (argv[GNoptind] + 1
-                + (longopts != NULL && argv[GNoptind][1] == '-'));
+    nextchar =
+        (argv[GNoptind] + 1 + (longopts != NULL && argv[GNoptind][1] == '-'));
   }
 
   /* Decode the current option-ARGV-element.  */
@@ -619,11 +617,10 @@ GN_getopt_internal (int argc,
    * 
    * This distinction seems to be the most useful approach.  */
 
-  if (longopts != NULL
-      && (argv[GNoptind][1] == '-'
-          || (long_only
-              && (argv[GNoptind][2]
-                  || !my_index (optstring, argv[GNoptind][1])))))
+  if (longopts != NULL &&
+      (argv[GNoptind][1] == '-' ||
+       (long_only &&
+        (argv[GNoptind][2] || !my_index (optstring, argv[GNoptind][1])))))
   {
     char *nameend;
     const struct GNoption *p;
@@ -641,8 +638,8 @@ GN_getopt_internal (int argc,
     for (p = longopts, option_index = 0; p->name; p++, option_index++)
       if (!strncmp (p->name, nextchar, nameend - nextchar))
       {
-        if ((unsigned int) (nameend - nextchar)
-            == (unsigned int) strlen (p->name))
+        if ((unsigned int) (nameend - nextchar) ==
+            (unsigned int) strlen (p->name))
         {
           /* Exact match found.  */
           pfound = p;
@@ -664,8 +661,8 @@ GN_getopt_internal (int argc,
     if (ambig && !exact)
     {
       if (GNopterr)
-        fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
-                 argv[0], argv[GNoptind]);
+        fprintf (stderr, _("%s: option `%s' is ambiguous\n"), argv[0],
+                 argv[GNoptind]);
       nextchar += strlen (nextchar);
       GNoptind++;
       return '?';
@@ -688,14 +685,12 @@ GN_getopt_internal (int argc,
             if (argv[GNoptind - 1][1] == '-')
               /* --option */
               fprintf (stderr,
-                       _
-                       ("%s: option `--%s' does not allow an argument\n"),
+                       _("%s: option `--%s' does not allow an argument\n"),
                        argv[0], pfound->name);
             else
               /* +option or -option */
               fprintf (stderr,
-                       _
-                       ("%s: option `%c%s' does not allow an argument\n"),
+                       _("%s: option `%c%s' does not allow an argument\n"),
                        argv[0], argv[GNoptind - 1][0], pfound->name);
           }
           nextchar += strlen (nextchar);
@@ -712,8 +707,7 @@ GN_getopt_internal (int argc,
         {
           if (GNopterr)
           {
-            fprintf (stderr,
-                     _("%s: option `%s' requires an argument\n"),
+            fprintf (stderr, _("%s: option `%s' requires an argument\n"),
                      argv[0], argv[GNoptind - 1]);
           }
           nextchar += strlen (nextchar);
@@ -735,19 +729,19 @@ GN_getopt_internal (int argc,
      * or the option starts with '--' or is not a valid short
      * option, then it's an error.
      * Otherwise interpret it as a short option.  */
-    if (!long_only || argv[GNoptind][1] == '-'
-        || my_index (optstring, *nextchar) == NULL)
+    if (!long_only || argv[GNoptind][1] == '-' ||
+        my_index (optstring, *nextchar) == NULL)
     {
       if (GNopterr)
       {
         if (argv[GNoptind][1] == '-')
           /* --option */
-          fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
-                   argv[0], nextchar);
+          fprintf (stderr, _("%s: unrecognized option `--%s'\n"), argv[0],
+                   nextchar);
         else
           /* +option or -option */
-          fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
-                   argv[0], argv[GNoptind][0], nextchar);
+          fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), argv[0],
+                   argv[GNoptind][0], nextchar);
       }
       nextchar = (char *) "";
       GNoptind++;
@@ -849,8 +843,8 @@ GN_getopt_internal (int argc,
       if (ambig && !exact)
       {
         if (GNopterr)
-          fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
-                   argv[0], argv[GNoptind]);
+          fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), argv[0],
+                   argv[GNoptind]);
         nextchar += strlen (nextchar);
         GNoptind++;
         return '?';
@@ -881,8 +875,7 @@ GN_getopt_internal (int argc,
           else
           {
             if (GNopterr)
-              fprintf (stderr,
-                       _("%s: option `%s' requires an argument\n"),
+              fprintf (stderr, _("%s: option `%s' requires an argument\n"),
                        argv[0], argv[GNoptind - 1]);
             nextchar += strlen (nextchar);
             return optstring[0] == ':' ? ':' : '?';
@@ -930,8 +923,8 @@ GN_getopt_internal (int argc,
           if (GNopterr)
           {
             /* 1003.2 specifies the format of this message.  */
-            fprintf (stderr,
-                     _("%s: option requires an argument -- %c\n"), argv[0], c);
+            fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+                     argv[0], c);
           }
           if (optstring[0] == ':')
             c = ':';
@@ -950,9 +943,7 @@ GN_getopt_internal (int argc,
 }
 
 static int
-GNgetopt_long (int argc,
-               char *const *argv,
-               const char *options,
+GNgetopt_long (int argc, char *const *argv, const char *options,
                const struct GNoption *long_options, int *opt_index)
 {
   return GN_getopt_internal (argc, argv, options, long_options, opt_index, 0);
@@ -1028,9 +1019,9 @@ GNUNET_GETOPT_run (const char *binaryOptions,
       clpc.currentArgument = GNoptind - 1;
       if ((char) c == allOptions[i].shortName)
       {
-        cont = allOptions[i].processor (&clpc,
-                                        allOptions[i].scls,
-                                        allOptions[i].name, GNoptarg);
+        cont =
+            allOptions[i].processor (&clpc, allOptions[i].scls,
+                                     allOptions[i].name, GNoptarg);
         break;
       }
     }
diff --git a/src/util/getopt_helpers.c b/src/util/getopt_helpers.c
index aa85bf536..d0c8c0e6a 100644
--- a/src/util/getopt_helpers.c
+++ b/src/util/getopt_helpers.c
@@ -166,9 +166,8 @@ OUTER:
  * @return GNUNET_OK 
  */
 int
-GNUNET_GETOPT_increment_value (struct
-                               GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-                               void *scls, const char *option,
+GNUNET_GETOPT_increment_value (struct GNUNET_GETOPT_CommandLineProcessorContext
+                               *ctx, void *scls, const char *option,
                                const char *value)
 {
   int *val = scls;
@@ -218,9 +217,8 @@ GNUNET_GETOPT_set_one (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @return GNUNET_OK 
  */
 int
-GNUNET_GETOPT_set_string (struct GNUNET_GETOPT_CommandLineProcessorContext
-                          *ctx, void *scls, const char *option,
-                          const char *value)
+GNUNET_GETOPT_set_string (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                          void *scls, const char *option, const char *value)
 {
   char **val = scls;
 
@@ -246,9 +244,8 @@ GNUNET_GETOPT_set_string (struct GNUNET_GETOPT_CommandLineProcessorContext
  * @return GNUNET_OK if parsing the value worked
  */
 int
-GNUNET_GETOPT_set_ulong (struct GNUNET_GETOPT_CommandLineProcessorContext
-                         *ctx, void *scls, const char *option,
-                         const char *value)
+GNUNET_GETOPT_set_ulong (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                         void *scls, const char *option, const char *value)
 {
   unsigned long long *val = scls;
 
diff --git a/src/util/gnunet-config-diff.c b/src/util/gnunet-config-diff.c
index 02ffa77a1..207b9518a 100644
--- a/src/util/gnunet-config-diff.c
+++ b/src/util/gnunet-config-diff.c
@@ -14,8 +14,7 @@ main (int argc, char **argv)
   }
   i1 = GNUNET_CONFIGURATION_create ();
   i2 = GNUNET_CONFIGURATION_create ();
-  if ((GNUNET_OK !=
-       GNUNET_CONFIGURATION_load (i1, argv[1])) ||
+  if ((GNUNET_OK != GNUNET_CONFIGURATION_load (i1, argv[1])) ||
       (GNUNET_OK != GNUNET_CONFIGURATION_load (i2, argv[2])))
     return 1;
   if (GNUNET_OK != GNUNET_CONFIGURATION_write_diffs (i1, i2, argv[2]))
diff --git a/src/util/gnunet-resolver.c b/src/util/gnunet-resolver.c
index 125d6665f..131693dd1 100644
--- a/src/util/gnunet-resolver.c
+++ b/src/util/gnunet-resolver.c
@@ -50,9 +50,8 @@ printer (void *cls, const struct sockaddr *addr, socklen_t addrlen)
  * @param cfg configuration
  */
 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)
 {
   if (args[0] == NULL)
     return;
@@ -73,11 +72,8 @@ main (int argc, char *const *argv)
     GNUNET_GETOPT_OPTION_END
   };
   return (GNUNET_OK ==
-          GNUNET_PROGRAM_run (argc,
-                              argv,
-                              "gnunet-resolver [hostname]",
-                              gettext_noop
-                              ("Test GNUnet DNS resolver code."),
+          GNUNET_PROGRAM_run (argc, argv, "gnunet-resolver [hostname]",
+                              gettext_noop ("Test GNUnet DNS resolver code."),
                               options, &run, NULL)) ? 0 : 1;
 }
 
diff --git a/src/util/gnunet-service-resolver.c b/src/util/gnunet-service-resolver.c
index f49ec3882..5d4c5c224 100644
--- a/src/util/gnunet-service-resolver.c
+++ b/src/util/gnunet-service-resolver.c
@@ -87,8 +87,9 @@ getnameinfo_resolve (struct IPCache *cache)
 {
   char hostname[256];
 
-  if (0 == getnameinfo (cache->sa,
-                        cache->salen, hostname, sizeof (hostname), NULL, 0, 0))
+  if (0 ==
+      getnameinfo (cache->sa, cache->salen, hostname, sizeof (hostname), NULL,
+                   0, 0))
     cache->addr = GNUNET_strdup (hostname);
 }
 #endif
@@ -108,12 +109,14 @@ gethostbyaddr_resolve (struct IPCache *cache)
   switch (cache->sa->sa_family)
   {
   case AF_INET:
-    ent = gethostbyaddr (&((struct sockaddr_in *) cache->sa)->sin_addr,
-                         sizeof (struct in_addr), AF_INET);
+    ent =
+        gethostbyaddr (&((struct sockaddr_in *) cache->sa)->sin_addr,
+                       sizeof (struct in_addr), AF_INET);
     break;
   case AF_INET6:
-    ent = gethostbyaddr (&((struct sockaddr_in6 *) cache->sa)->sin6_addr,
-                         sizeof (struct in6_addr), AF_INET6);
+    ent =
+        gethostbyaddr (&((struct sockaddr_in6 *) cache->sa)->sin6_addr,
+                       sizeof (struct in6_addr), AF_INET6);
     break;
   default:
     ent = NULL;
@@ -225,8 +228,7 @@ get_ip_as_string (struct GNUNET_SERVER_Client *client,
   }
   tc = GNUNET_SERVER_transmit_context_create (client);
   if (cache->addr != NULL)
-    GNUNET_SERVER_transmit_context_append_data (tc,
-                                                cache->addr,
+    GNUNET_SERVER_transmit_context_append_data (tc, cache->addr,
                                                 strlen (cache->addr) + 1,
                                                 GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
@@ -256,11 +258,10 @@ getaddrinfo_resolve (struct GNUNET_SERVER_TransmitContext *tc,
 
   if (0 != (s = getaddrinfo (hostname, NULL, &hints, &result)))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Could not resolve `%s' (%s): %s\n"), hostname,
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Could not resolve `%s' (%s): %s\n"),
+                hostname,
                 (domain ==
-                 AF_INET) ? "IPv4" : ((domain ==
-                                       AF_INET6) ? "IPv6" : "any"),
+                 AF_INET) ? "IPv4" : ((domain == AF_INET6) ? "IPv6" : "any"),
                 gai_strerror (s));
     if ((s == EAI_BADFLAGS) || (s == EAI_MEMORY)
 #ifndef MINGW
@@ -278,8 +279,7 @@ getaddrinfo_resolve (struct GNUNET_SERVER_TransmitContext *tc,
   pos = result;
   while (pos != NULL)
   {
-    GNUNET_SERVER_transmit_context_append_data (tc,
-                                                pos->ai_addr,
+    GNUNET_SERVER_transmit_context_append_data (tc, pos->ai_addr,
                                                 pos->ai_addrlen,
                                                 GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
     pos = pos->ai_next;
@@ -314,8 +314,8 @@ gethostbyname2_resolve (struct GNUNET_SERVER_TransmitContext *tc,
   if (hp == NULL)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Could not find IP of host `%s': %s\n"),
-                hostname, hstrerror (h_errno));
+                _("Could not find IP of host `%s': %s\n"), hostname,
+                hstrerror (h_errno));
     return GNUNET_SYSERR;
   }
   GNUNET_assert (hp->h_addrtype == domain);
@@ -328,9 +328,7 @@ gethostbyname2_resolve (struct GNUNET_SERVER_TransmitContext *tc,
     a4.sin_len = (u_char) sizeof (struct sockaddr_in);
 #endif
     memcpy (&a4.sin_addr, hp->h_addr_list[0], hp->h_length);
-    GNUNET_SERVER_transmit_context_append_data (tc,
-                                                &a4,
-                                                sizeof (a4),
+    GNUNET_SERVER_transmit_context_append_data (tc, &a4, sizeof (a4),
                                                 GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
   }
   else
@@ -342,9 +340,7 @@ gethostbyname2_resolve (struct GNUNET_SERVER_TransmitContext *tc,
     a6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
 #endif
     memcpy (&a6.sin6_addr, hp->h_addr_list[0], hp->h_length);
-    GNUNET_SERVER_transmit_context_append_data (tc,
-                                                &a6,
-                                                sizeof (a6),
+    GNUNET_SERVER_transmit_context_append_data (tc, &a6, sizeof (a6),
                                                 GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
   }
   return GNUNET_OK;
@@ -363,8 +359,8 @@ gethostbyname_resolve (struct GNUNET_SERVER_TransmitContext *tc,
   if (hp == NULL)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Could not find IP of host `%s': %s\n"),
-                hostname, hstrerror (h_errno));
+                _("Could not find IP of host `%s': %s\n"), hostname,
+                hstrerror (h_errno));
     return GNUNET_SYSERR;
   }
   if (hp->h_addrtype != AF_INET)
@@ -379,9 +375,7 @@ gethostbyname_resolve (struct GNUNET_SERVER_TransmitContext *tc,
   addr.sin_len = (u_char) sizeof (struct sockaddr_in);
 #endif
   memcpy (&addr.sin_addr, hp->h_addr_list[0], hp->h_length);
-  GNUNET_SERVER_transmit_context_append_data (tc,
-                                              &addr,
-                                              sizeof (addr),
+  GNUNET_SERVER_transmit_context_append_data (tc, &addr, sizeof (addr),
                                               GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
   return GNUNET_OK;
 }
@@ -396,8 +390,8 @@ gethostbyname_resolve (struct GNUNET_SERVER_TransmitContext *tc,
  * @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
  */
 static void
-get_ip_from_hostname (struct GNUNET_SERVER_Client *client,
-                      const char *hostname, int domain)
+get_ip_from_hostname (struct GNUNET_SERVER_Client *client, const char *hostname,
+                      int domain)
 {
   int ret;
   struct GNUNET_SERVER_TransmitContext *tc;
@@ -430,8 +424,7 @@ get_ip_from_hostname (struct GNUNET_SERVER_Client *client,
  * @param message the actual message
  */
 static void
-handle_get (void *cls,
-            struct GNUNET_SERVER_Client *client,
+handle_get (void *cls, struct GNUNET_SERVER_Client *client,
             const struct GNUNET_MessageHeader *message)
 {
   uint16_t msize;
@@ -464,8 +457,8 @@ handle_get (void *cls,
       return;
     }
 #if DEBUG_RESOLVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _("Resolver asked to look up `%s'.\n"), hostname);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolver asked to look up `%s'.\n"),
+                hostname);
 #endif
     get_ip_from_hostname (client, hostname, domain);
   }
@@ -527,8 +520,7 @@ handle_get (void *cls,
  * @param cfg configuration to use
  */
 static void
-run (void *cls,
-     struct GNUNET_SERVER_Handle *server,
+run (void *cls, struct GNUNET_SERVER_Handle *server,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
@@ -552,11 +544,10 @@ main (int argc, char *const *argv)
   int ret;
   struct IPCache *pos;
 
-  ret = (GNUNET_OK ==
-         GNUNET_SERVICE_run (argc,
-                             argv,
-                             "resolver", GNUNET_SERVICE_OPTION_NONE,
-                             &run, NULL)) ? 0 : 1;
+  ret =
+      (GNUNET_OK ==
+       GNUNET_SERVICE_run (argc, argv, "resolver", GNUNET_SERVICE_OPTION_NONE,
+                           &run, NULL)) ? 0 : 1;
 
   while (head != NULL)
   {
diff --git a/src/util/network.c b/src/util/network.c
index b533ce183..e071b8b54 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -212,8 +212,7 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
     int gsn = getsockname (desc->fd, &name, &namelen);
 
     if (gsn == 0)
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Accepting connection on `%s'\n",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Accepting connection on `%s'\n",
                   GNUNET_a2s (&name, namelen));
   }
 #endif
@@ -357,8 +356,8 @@ GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)
     const struct sockaddr_un *un = (const struct sockaddr_un *) desc->addr;
 
     if (0 != unlink (un->sun_path))
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                "unlink", un->sun_path);
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink",
+                                un->sun_path);
   }
 #endif
 #endif
@@ -480,8 +479,8 @@ GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
  * @param desc socket
  */
 ssize_t
-GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle
-                                       * desc)
+GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle *
+                                       desc)
 {
   int error;
 
@@ -645,9 +644,8 @@ GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,
-                                  int level, int option_name,
-                                  const void *option_value,
+GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd, int level,
+                                  int option_name, const void *option_value,
                                   socklen_t option_len)
 {
   int ret;
@@ -945,8 +943,8 @@ GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,
 {
 #ifdef MINGW
   GNUNET_CONTAINER_slist_add (fds->handles,
-                              GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-                              h, sizeof (struct GNUNET_DISK_FileHandle));
+                              GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, h,
+                              sizeof (struct GNUNET_DISK_FileHandle));
 
 #else
   int fd;
@@ -1569,10 +1567,9 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
                     "send to the socket %d returned %d (%u)\n", i, status,
                     error);
 #endif
-        if (status == 0
-            || (error != WSAEWOULDBLOCK && error != WSAENOTCONN)
-            || (status == -1 && gso_result == 0 && error == WSAENOTCONN &&
-                so_error == WSAECONNREFUSED))
+        if (status == 0 || (error != WSAEWOULDBLOCK && error != WSAENOTCONN) ||
+            (status == -1 && gso_result == 0 && error == WSAENOTCONN &&
+             so_error == WSAECONNREFUSED))
         {
           FD_SET (wfds->sds.fd_array[i], &awrite);
           retcode += 1;
diff --git a/src/util/os_installation.c b/src/util/os_installation.c
index 188401abb..00825f2b7 100644
--- a/src/util/os_installation.c
+++ b/src/util/os_installation.c
@@ -57,9 +57,9 @@ get_path_from_proc_maps ()
     return NULL;
   while (NULL != fgets (line, sizeof (line), f))
   {
-    if ((1 == sscanf (line,
-                      "%*x-%*x %*c%*c%*c%*c %*x %*2u:%*2u %*u%*[ ]%s",
-                      dir)) && (NULL != (lgu = strstr (dir, "libgnunetutil"))))
+    if ((1 ==
+         sscanf (line, "%*x-%*x %*c%*c%*c%*c %*x %*2u:%*2u %*u%*[ ]%s", dir)) &&
+        (NULL != (lgu = strstr (dir, "libgnunetutil"))))
     {
       lgu[0] = '\0';
       fclose (f);
@@ -476,8 +476,8 @@ GNUNET_OS_check_helper_binary (const char *binary)
   }
   if (0 != STAT (p, &statbuf))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("stat (%s) failed: %s\n"), p, STRERROR (errno));
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("stat (%s) failed: %s\n"), p,
+                STRERROR (errno));
     GNUNET_free (p);
     return GNUNET_SYSERR;
   }
diff --git a/src/util/os_network.c b/src/util/os_network.c
index af8046814..21376f94c 100644
--- a/src/util/os_network.c
+++ b/src/util/os_network.c
@@ -131,15 +131,12 @@ GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
 
         /* Set entry */
         memset (bPhysAddr, 0, MAXLEN_PHYSADDR);
-        memcpy (bPhysAddr,
-                pTable->table[dwIfIdx].bPhysAddr,
+        memcpy (bPhysAddr, pTable->table[dwIfIdx].bPhysAddr,
                 pTable->table[dwIfIdx].dwPhysAddrLen);
 
         snprintf (szEntry, 1000, "%s (%s - %I64u)",
-                  pszIfName ? pszIfName : (char *)
-                  pTable->table[dwIfIdx].bDescr, inet_ntop (AF_INET,
-                                                            &dwIP, dst,
-                                                            INET_ADDRSTRLEN),
+                  pszIfName ? pszIfName : (char *) pTable->table[dwIfIdx].
+                  bDescr, inet_ntop (AF_INET, &dwIP, dst, INET_ADDRSTRLEN),
                   *((unsigned long long *) bPhysAddr));
         szEntry[1000] = 0;
 
@@ -153,8 +150,7 @@ GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
         sa.sin_addr.S_un.S_addr = dwIP;
 
         if (GNUNET_OK !=
-            proc (proc_cls,
-                  szEntry,
+            proc (proc_cls, szEntry,
                   pTable->table[dwIfIdx].dwIndex == dwExternalNIC,
                   (const struct sockaddr *) &sa, sizeof (sa)))
           break;
@@ -176,8 +172,8 @@ GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
   {
     for (ifa_ptr = ifa_first; ifa_ptr != NULL; ifa_ptr = ifa_ptr->ifa_next)
     {
-      if (ifa_ptr->ifa_name != NULL &&
-          ifa_ptr->ifa_addr != NULL && (ifa_ptr->ifa_flags & IFF_UP) != 0)
+      if (ifa_ptr->ifa_name != NULL && ifa_ptr->ifa_addr != NULL &&
+          (ifa_ptr->ifa_flags & IFF_UP) != 0)
       {
         if ((ifa_ptr->ifa_addr->sa_family != AF_INET) &&
             (ifa_ptr->ifa_addr->sa_family != AF_INET6))
@@ -186,11 +182,10 @@ GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
           alen = sizeof (struct sockaddr_in);
         else
           alen = sizeof (struct sockaddr_in6);
-        if (GNUNET_OK != proc (proc_cls,
-                               ifa_ptr->ifa_name,
-                               0 == strcmp (ifa_ptr->ifa_name,
-                                            GNUNET_DEFAULT_INTERFACE),
-                               ifa_ptr->ifa_addr, alen))
+        if (GNUNET_OK !=
+            proc (proc_cls, ifa_ptr->ifa_name,
+                  0 == strcmp (ifa_ptr->ifa_name, GNUNET_DEFAULT_INTERFACE),
+                  ifa_ptr->ifa_addr, alen))
           break;
       }
     }
@@ -261,9 +256,7 @@ GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
 #endif
         a4.sin_addr = v4;
         if (GNUNET_OK !=
-            proc (proc_cls,
-                  ifc,
-                  0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
+            proc (proc_cls, ifc, 0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
                   (const struct sockaddr *) &a4, sizeof (a4)))
           break;
         continue;
@@ -278,9 +271,7 @@ GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
 #endif
         a6.sin6_addr = v6;
         if (GNUNET_OK !=
-            proc (proc_cls,
-                  ifc,
-                  0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
+            proc (proc_cls, ifc, 0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
                   (const struct sockaddr *) &a6, sizeof (a6)))
           break;
         continue;
diff --git a/src/util/os_priority.c b/src/util/os_priority.c
index bccde8d46..d27642a58 100644
--- a/src/util/os_priority.c
+++ b/src/util/os_priority.c
@@ -60,19 +60,20 @@ parent_control_handler (void *cls,
   int sig;
 
 #if DEBUG_OS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "`%s' invoked because of %d\n", __FUNCTION__, tc->reason);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' invoked because of %d\n",
+              __FUNCTION__, tc->reason);
 #endif
-  if (tc->reason & (GNUNET_SCHEDULER_REASON_SHUTDOWN |
-                    GNUNET_SCHEDULER_REASON_TIMEOUT |
-                    GNUNET_SCHEDULER_REASON_PREREQ_DONE))
+  if (tc->
+      reason & (GNUNET_SCHEDULER_REASON_SHUTDOWN |
+                GNUNET_SCHEDULER_REASON_TIMEOUT |
+                GNUNET_SCHEDULER_REASON_PREREQ_DONE))
   {
     GNUNET_DISK_npipe_close (control_pipe);
   }
   else
   {
-    if (GNUNET_DISK_file_read (control_pipe,
-                               &sig, sizeof (sig)) != sizeof (sig))
+    if (GNUNET_DISK_file_read (control_pipe, &sig, sizeof (sig)) !=
+        sizeof (sig))
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
       GNUNET_DISK_npipe_close (control_pipe);
@@ -80,12 +81,12 @@ parent_control_handler (void *cls,
     else
     {
 #if DEBUG_OS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Got control code %d from parent\n", sig);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got control code %d from parent\n",
+                  sig);
 #endif
       GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      control_pipe,
-                                      &parent_control_handler, control_pipe);
+                                      control_pipe, &parent_control_handler,
+                                      control_pipe);
       raise (sig);
     }
   }
@@ -111,10 +112,10 @@ GNUNET_OS_install_parent_control_handler (void *cls,
                 GNUNET_OS_CONTROL_PIPE, env_buf);
     return;
   }
-  control_pipe = GNUNET_DISK_npipe_open (env_buf,
-                                         GNUNET_DISK_OPEN_READ,
-                                         GNUNET_DISK_PERM_USER_READ |
-                                         GNUNET_DISK_PERM_USER_WRITE);
+  control_pipe =
+      GNUNET_DISK_npipe_open (env_buf, GNUNET_DISK_OPEN_READ,
+                              GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
   {
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
@@ -125,8 +126,7 @@ GNUNET_OS_install_parent_control_handler (void *cls,
               "Adding parent control handler pipe `%s' to the scheduler\n",
               env_buf);
 #endif
-  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  control_pipe,
+  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, control_pipe,
                                   &parent_control_handler, control_pipe);
 }
 
@@ -219,13 +219,14 @@ GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
      */
     while (1)
     {
-      ret = GNUNET_NETWORK_socket_select (rfds, NULL, efds,
-                                          GNUNET_TIME_relative_multiply
-                                          (GNUNET_TIME_relative_get_unit (),
-                                           5000));
-
-      if (ret < 1 || GNUNET_NETWORK_fdset_handle_isset (efds,
-                                                        proc->control_pipe))
+      ret =
+          GNUNET_NETWORK_socket_select (rfds, NULL, efds,
+                                        GNUNET_TIME_relative_multiply
+                                        (GNUNET_TIME_relative_get_unit (),
+                                         5000));
+
+      if (ret < 1 ||
+          GNUNET_NETWORK_fdset_handle_isset (efds, proc->control_pipe))
       {
         /* Just to be sure */
         PLIBC_KILL (proc->pid, sig);
@@ -234,8 +235,8 @@ GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
       }
       else
       {
-        if (GNUNET_DISK_file_read (proc->control_pipe, &ret,
-                                   sizeof (ret)) != GNUNET_OK)
+        if (GNUNET_DISK_file_read (proc->control_pipe, &ret, sizeof (ret)) !=
+            GNUNET_OK)
           res = PLIBC_KILL (proc->pid, sig);
 
         /* Child signaled shutdown is in progress */
@@ -394,8 +395,8 @@ GNUNET_OS_set_process_priority (struct GNUNET_OS_Process *proc,
     errno = 0;
     if ((delta != 0) && (rprio == nice (delta)) && (errno != 0))
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
-                           GNUNET_ERROR_TYPE_BULK, "nice");
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                           "nice");
       return GNUNET_SYSERR;
     }
   }
@@ -403,8 +404,8 @@ GNUNET_OS_set_process_priority (struct GNUNET_OS_Process *proc,
   {
     if (0 != setpriority (PRIO_PROCESS, pid, rprio))
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
-                           GNUNET_ERROR_TYPE_BULK, "setpriority");
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                           "setpriority");
       return GNUNET_SYSERR;
     }
   }
@@ -552,10 +553,10 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
   int fd_stdin_write;
 
 #if ENABLE_WINDOWS_WORKAROUNDS
-  control_pipe = GNUNET_DISK_npipe_create (&childpipename,
-                                           GNUNET_DISK_OPEN_WRITE,
-                                           GNUNET_DISK_PERM_USER_READ |
-                                           GNUNET_DISK_PERM_USER_WRITE);
+  control_pipe =
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
     return NULL;
 #endif
@@ -776,10 +777,10 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
     start.hStdOutput = stdout_handle;
   }
 
-  control_pipe = GNUNET_DISK_npipe_create (&childpipename,
-                                           GNUNET_DISK_OPEN_WRITE,
-                                           GNUNET_DISK_PERM_USER_READ |
-                                           GNUNET_DISK_PERM_USER_WRITE);
+  control_pipe =
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
   {
     GNUNET_free (cmd);
@@ -865,8 +866,8 @@ GNUNET_OS_start_process (struct GNUNET_DISK_PipeHandle *pipe_stdin,
  * @return process ID of the new process, -1 on error
  */
 struct GNUNET_OS_Process *
-GNUNET_OS_start_process_v (const int *lsocks,
-                           const char *filename, char *const argv[])
+GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
+                           char *const argv[])
 {
 #if ENABLE_WINDOWS_WORKAROUNDS
   struct GNUNET_DISK_FileHandle *control_pipe = NULL;
@@ -887,10 +888,10 @@ GNUNET_OS_start_process_v (const int *lsocks,
   unsigned int ls;
 
 #if ENABLE_WINDOWS_WORKAROUNDS
-  control_pipe = GNUNET_DISK_npipe_create (&childpipename,
-                                           GNUNET_DISK_OPEN_WRITE,
-                                           GNUNET_DISK_PERM_USER_READ |
-                                           GNUNET_DISK_PERM_USER_WRITE);
+  control_pipe =
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
     return NULL;
 #endif
@@ -1121,10 +1122,10 @@ GNUNET_OS_start_process_v (const int *lsocks,
   memset (&start, 0, sizeof (start));
   start.cb = sizeof (start);
 
-  control_pipe = GNUNET_DISK_npipe_create (&childpipename,
-                                           GNUNET_DISK_OPEN_WRITE,
-                                           GNUNET_DISK_PERM_USER_READ |
-                                           GNUNET_DISK_PERM_USER_WRITE);
+  control_pipe =
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
   {
     GNUNET_free (cmd);
@@ -1414,9 +1415,9 @@ cmd_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     proc (cmd->proc_cls, NULL);
     return;
   }
-  ret = GNUNET_DISK_file_read (cmd->r,
-                               &cmd->buf[cmd->off],
-                               sizeof (cmd->buf) - cmd->off);
+  ret =
+      GNUNET_DISK_file_read (cmd->r, &cmd->buf[cmd->off],
+                             sizeof (cmd->buf) - cmd->off);
   if (ret <= 0)
   {
     if ((cmd->off > 0) && (cmd->off < sizeof (cmd->buf)))
@@ -1457,10 +1458,9 @@ cmd_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return NULL on error
  */
 struct GNUNET_OS_CommandHandle *
-GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc,
-                       void *proc_cls,
-                       struct GNUNET_TIME_Relative timeout,
-                       const char *binary, ...)
+GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls,
+                       struct GNUNET_TIME_Relative timeout, const char *binary,
+                       ...)
 {
   struct GNUNET_OS_CommandHandle *cmd;
   struct GNUNET_OS_Process *eip;
diff --git a/src/util/peer.c b/src/util/peer.c
index 91a706040..62fa0e2f2 100644
--- a/src/util/peer.c
+++ b/src/util/peer.c
@@ -148,8 +148,7 @@ GNUNET_PEER_intern (const struct GNUNET_PeerIdentity *pid)
   table[ret].rc = 1;
   table[ret].pid = ret;
   GNUNET_break (GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put (map,
-                                                   &pid->hashPubKey,
+                GNUNET_CONTAINER_multihashmap_put (map, &pid->hashPubKey,
                                                    (void *) (long) ret,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return ret;
@@ -182,8 +181,8 @@ GNUNET_PEER_decrement_rcs (const GNUNET_PEER_Id *ids, unsigned int count)
     {
       GNUNET_break (GNUNET_OK ==
                     GNUNET_CONTAINER_multihashmap_remove (map,
-                                                          &table[id].
-                                                          id.hashPubKey,
+                                                          &table[id].id.
+                                                          hashPubKey,
                                                           (void *) (long) id));
       table[id].pid = free_list_start;
       free_list_start = id;
@@ -211,8 +210,8 @@ GNUNET_PEER_change_rc (GNUNET_PEER_Id id, int delta)
   {
     GNUNET_break (GNUNET_OK ==
                   GNUNET_CONTAINER_multihashmap_remove (map,
-                                                        &table[id].
-                                                        id.hashPubKey,
+                                                        &table[id].id.
+                                                        hashPubKey,
                                                         (void *) (long) id));
     table[id].pid = free_list_start;
     free_list_start = id;
diff --git a/src/util/perf_crypto_hash.c b/src/util/perf_crypto_hash.c
index d883776b4..689781835 100644
--- a/src/util/perf_crypto_hash.c
+++ b/src/util/perf_crypto_hash.c
@@ -58,12 +58,12 @@ main (int argc, char *argv[])
   start = GNUNET_TIME_absolute_get ();
   perfHash ();
   printf ("Hash perf took %llu ms\n",
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value);
   GAUGER ("UTIL", "Cryptographic hashing",
           1024 * 64 * 1024 / (1 +
-                              GNUNET_TIME_absolute_get_duration
-                              (start).rel_value), "kb/s");
+                              GNUNET_TIME_absolute_get_duration (start).
+                              rel_value), "kb/s");
   return 0;
 }
 
diff --git a/src/util/plugin.c b/src/util/plugin.c
index b1c979dff..08b32b295 100644
--- a/src/util/plugin.c
+++ b/src/util/plugin.c
@@ -84,8 +84,7 @@ plugin_init ()
   err = lt_dlinit ();
   if (err > 0)
   {
-    fprintf (stderr,
-             _("Initialization of plugin mechanism failed: %s!\n"),
+    fprintf (stderr, _("Initialization of plugin mechanism failed: %s!\n"),
              lt_dlerror ());
     return;
   }
diff --git a/src/util/program.c b/src/util/program.c
index cccb7db73..f1e95477d 100644
--- a/src/util/program.c
+++ b/src/util/program.c
@@ -124,9 +124,7 @@ cmd_sorter (__const void *a1, __const void *a2)
  * @return GNUNET_SYSERR on error, GNUNET_OK on success
  */
 int
-GNUNET_PROGRAM_run (int argc,
-                    char *const *argv,
-                    const char *binaryName,
+GNUNET_PROGRAM_run (int argc, char *const *argv, const char *binaryName,
                     const char *binaryHelp,
                     const struct GNUNET_GETOPT_CommandLineOption *options,
                     GNUNET_PROGRAM_Main task, void *task_cls)
@@ -217,13 +215,10 @@ GNUNET_PROGRAM_run (int argc,
   lpfx = GNUNET_strdup (binaryName);
   if (NULL != (spc = strstr (lpfx, " ")))
     *spc = '\0';
-  if ((-1 == (ret = GNUNET_GETOPT_run (binaryName,
-                                       allopts,
-                                       (unsigned int) argc, argv))) ||
-      ((GNUNET_OK !=
-        GNUNET_log_setup (lpfx,
-                          loglev,
-                          logfile)) ||
+  if ((-1 ==
+       (ret =
+        GNUNET_GETOPT_run (binaryName, allopts, (unsigned int) argc, argv))) ||
+      ((GNUNET_OK != GNUNET_log_setup (lpfx, loglev, logfile)) ||
        (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cc.cfgfile))))
   {
     GNUNET_CONFIGURATION_destroy (cfg);
diff --git a/src/util/pseudonym.c b/src/util/pseudonym.c
index 254decb76..85a485098 100644
--- a/src/util/pseudonym.c
+++ b/src/util/pseudonym.c
@@ -99,8 +99,7 @@ internal_notify (const GNUNET_HashCode * id,
  */
 int
 GNUNET_PSEUDONYM_discovery_callback_register (const struct
-                                              GNUNET_CONFIGURATION_Handle
-                                              *cfg,
+                                              GNUNET_CONFIGURATION_Handle *cfg,
                                               GNUNET_PSEUDONYM_Iterator
                                               iterator, void *closure)
 {
@@ -155,16 +154,14 @@ GNUNET_PSEUDONYM_discovery_callback_unregister (GNUNET_PSEUDONYM_Iterator
  * @return filename of the pseudonym (if psid != NULL) or directory with the data (if psid == NULL)
  */
 static char *
-get_data_filename (const struct GNUNET_CONFIGURATION_Handle
-                   *cfg, const char *prefix, const GNUNET_HashCode * psid)
+get_data_filename (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                   const char *prefix, const GNUNET_HashCode * psid)
 {
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
   if (psid != NULL)
     GNUNET_CRYPTO_hash_to_enc (psid, &enc);
-  return GNUNET_DISK_get_home_filename (cfg,
-                                        GNUNET_CLIENT_SERVICE_NAME,
-                                        prefix,
+  return GNUNET_DISK_get_home_filename (cfg, GNUNET_CLIENT_SERVICE_NAME, prefix,
                                         (psid ==
                                          NULL) ? NULL : (const char *) &enc,
                                         NULL);
@@ -228,8 +225,8 @@ write_pseudonym_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
 static int
 read_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
            const GNUNET_HashCode * nsid,
-           struct GNUNET_CONTAINER_MetaData **meta,
-           int32_t * ranking, char **ns_name)
+           struct GNUNET_CONTAINER_MetaData **meta, int32_t * ranking,
+           char **ns_name)
 {
   char *fn;
   char *emsg;
@@ -309,16 +306,17 @@ GNUNET_PSEUDONYM_id_to_name (const struct GNUNET_CONFIGURATION_Handle *cfg,
   if (GNUNET_OK == read_info (cfg, nsid, &meta, rank, &name))
   {
     if ((meta != NULL) && (name == NULL))
-      name = GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
-                                                            EXTRACTOR_METATYPE_TITLE,
-                                                            EXTRACTOR_METATYPE_FILENAME,
-                                                            EXTRACTOR_METATYPE_DESCRIPTION,
-                                                            EXTRACTOR_METATYPE_SUBJECT,
-                                                            EXTRACTOR_METATYPE_PUBLISHER,
-                                                            EXTRACTOR_METATYPE_AUTHOR_NAME,
-                                                            EXTRACTOR_METATYPE_COMMENT,
-                                                            EXTRACTOR_METATYPE_SUMMARY,
-                                                            -1);
+      name =
+          GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
+                                                         EXTRACTOR_METATYPE_TITLE,
+                                                         EXTRACTOR_METATYPE_FILENAME,
+                                                         EXTRACTOR_METATYPE_DESCRIPTION,
+                                                         EXTRACTOR_METATYPE_SUBJECT,
+                                                         EXTRACTOR_METATYPE_PUBLISHER,
+                                                         EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                                         EXTRACTOR_METATYPE_COMMENT,
+                                                         EXTRACTOR_METATYPE_SUMMARY,
+                                                         -1);
     if (meta != NULL)
     {
       GNUNET_CONTAINER_meta_data_destroy (meta);
@@ -334,15 +332,16 @@ GNUNET_PSEUDONYM_id_to_name (const struct GNUNET_CONFIGURATION_Handle *cfg,
   len = 0;
   if (0 == STAT (fn, &sbuf))
     GNUNET_DISK_file_size (fn, &len, GNUNET_YES);
-  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_CREATE
-                              | GNUNET_DISK_OPEN_READWRITE,
+  fh = GNUNET_DISK_file_open (fn,
+                              GNUNET_DISK_OPEN_CREATE |
+                              GNUNET_DISK_OPEN_READWRITE,
                               GNUNET_DISK_PERM_USER_READ |
                               GNUNET_DISK_PERM_USER_WRITE);
   i = 0;
   idx = -1;
   while ((len >= sizeof (GNUNET_HashCode)) &&
-         (sizeof (GNUNET_HashCode)
-          == GNUNET_DISK_file_read (fh, &nh, sizeof (GNUNET_HashCode))))
+         (sizeof (GNUNET_HashCode) ==
+          GNUNET_DISK_file_read (fh, &nh, sizeof (GNUNET_HashCode))))
   {
     if (0 == memcmp (&nh, nsid, sizeof (GNUNET_HashCode)))
     {
@@ -407,8 +406,9 @@ GNUNET_PSEUDONYM_name_to_id (const struct GNUNET_CONFIGURATION_Handle *cfg,
     GNUNET_free (fn);
     return GNUNET_SYSERR;
   }
-  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_CREATE
-                              | GNUNET_DISK_OPEN_READWRITE,
+  fh = GNUNET_DISK_file_open (fn,
+                              GNUNET_DISK_OPEN_CREATE |
+                              GNUNET_DISK_OPEN_READWRITE,
                               GNUNET_DISK_PERM_USER_READ |
                               GNUNET_DISK_PERM_USER_WRITE);
   GNUNET_free (fn);
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index ef48faf59..3aa8bff9c 100644
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.c
@@ -191,17 +191,16 @@ check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
   v6.sin6_len = sizeof (v6);
 #endif
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "resolver", "HOSTNAME", &hostname))
+      GNUNET_CONFIGURATION_get_value_string (cfg, "resolver", "HOSTNAME",
+                                             &hostname))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Must specify `%s' for `%s' in configuration!\n"),
-                "HOSTNAME", "resolver");
+                _("Must specify `%s' for `%s' in configuration!\n"), "HOSTNAME",
+                "resolver");
     GNUNET_assert (0);
   }
-  if ((1 != inet_pton (AF_INET,
-                       hostname,
-                       &v4)) || (1 != inet_pton (AF_INET6, hostname, &v6)))
+  if ((1 != inet_pton (AF_INET, hostname, &v4)) ||
+      (1 != inet_pton (AF_INET6, hostname, &v6)))
   {
     GNUNET_free (hostname);
     return;
@@ -288,9 +287,8 @@ no_resolve (const struct sockaddr *sa, socklen_t salen)
     if (salen != sizeof (struct sockaddr_in))
       return NULL;
     if (NULL ==
-        inet_ntop (AF_INET,
-                   &((struct sockaddr_in *) sa)->sin_addr,
-                   inet4, INET_ADDRSTRLEN))
+        inet_ntop (AF_INET, &((struct sockaddr_in *) sa)->sin_addr, inet4,
+                   INET_ADDRSTRLEN))
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
       return NULL;
@@ -301,9 +299,8 @@ no_resolve (const struct sockaddr *sa, socklen_t salen)
     if (salen != sizeof (struct sockaddr_in6))
       return NULL;
     if (NULL ==
-        inet_ntop (AF_INET6,
-                   &((struct sockaddr_in6 *) sa)->sin6_addr,
-                   inet6, INET6_ADDRSTRLEN))
+        inet_ntop (AF_INET6, &((struct sockaddr_in6 *) sa)->sin6_addr, inet6,
+                   INET6_ADDRSTRLEN))
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
       return NULL;
@@ -427,15 +424,13 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
     }
 #if DEBUG_RESOLVER
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _("Resolver returns `%s' for IP `%s'.\n"),
-                hostname, GNUNET_a2s ((const void *) &rh[1], rh->data_len));
+                _("Resolver returns `%s' for IP `%s'.\n"), hostname,
+                GNUNET_a2s ((const void *) &rh[1], rh->data_len));
 #endif
     if (rh->was_transmitted != GNUNET_SYSERR)
       rh->name_callback (rh->cls, hostname);
     rh->received_response = GNUNET_YES;
-    GNUNET_CLIENT_receive (client,
-                           &handle_response,
-                           rh,
+    GNUNET_CLIENT_receive (client, &handle_response, rh,
                            GNUNET_TIME_absolute_get_remaining (rh->timeout));
   }
   /* return lookup results to caller */
@@ -459,16 +454,13 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
     {
       char *ips = no_resolve (sa, salen);
 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Resolver returns `%s' for `%s'.\n",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Resolver returns `%s' for `%s'.\n",
                   ips, (const char *) &rh[1]);
       GNUNET_free (ips);
     }
 #endif
     rh->addr_callback (rh->cls, sa, salen);
-    GNUNET_CLIENT_receive (client,
-                           &handle_response,
-                           rh,
+    GNUNET_CLIENT_receive (client, &handle_response, rh,
                            GNUNET_TIME_absolute_get_remaining (rh->timeout));
   }
 }
@@ -610,8 +602,9 @@ process_requests ()
   {
     /* nothing to do, release socket really soon if there is nothing
      * else happening... */
-    s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
-                                           &shutdown_task, NULL);
+    s_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
+                                      &shutdown_task, NULL);
     return;
   }
   if (GNUNET_YES == rh->was_transmitted)
@@ -628,8 +621,7 @@ process_requests ()
               "Transmitting DNS resolution request to DNS service\n");
 #endif
   if (GNUNET_OK !=
-      GNUNET_CLIENT_transmit_and_get_response (client,
-                                               &msg->header,
+      GNUNET_CLIENT_transmit_and_get_response (client, &msg->header,
                                                GNUNET_TIME_absolute_get_remaining
                                                (rh->timeout), GNUNET_YES,
                                                &handle_response, rh))
@@ -726,8 +718,7 @@ reconnect ()
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_ip_get (const char *hostname,
-                        int domain,
+GNUNET_RESOLVER_ip_get (const char *hostname, int domain,
                         struct GNUNET_TIME_Relative timeout,
                         GNUNET_RESOLVER_AddressCallback callback,
                         void *callback_cls)
@@ -754,13 +745,9 @@ GNUNET_RESOLVER_ip_get (const char *hostname,
   rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   rh->direction = GNUNET_NO;
   /* first, check if this is a numeric address */
-  if (((1 == inet_pton (AF_INET,
-                        hostname,
-                        &v4)) &&
+  if (((1 == inet_pton (AF_INET, hostname, &v4)) &&
        ((domain == AF_INET) || (domain == AF_UNSPEC))) ||
-      ((1 == inet_pton (AF_INET6,
-                        hostname,
-                        &v6)) &&
+      ((1 == inet_pton (AF_INET6, hostname, &v6)) &&
        ((domain == AF_INET6) || (domain == AF_UNSPEC))))
   {
     rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution, rh);
@@ -826,8 +813,7 @@ numeric_reverse (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return handle that can be used to cancel the request
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
-                              socklen_t salen,
+GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen,
                               int do_resolve,
                               struct GNUNET_TIME_Relative timeout,
                               GNUNET_RESOLVER_HostnameCallback callback,
@@ -881,19 +867,19 @@ GNUNET_RESOLVER_local_fqdn_get ()
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
-                         GNUNET_ERROR_TYPE_BULK, "gethostname");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "gethostname");
     return NULL;
   }
 #if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Resolving our FQDN `%s'\n"), hostname);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolving our FQDN `%s'\n"),
+              hostname);
 #endif
   host = gethostbyname (hostname);
   if (NULL == host)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Could not resolve our FQDN : %s\n"), hstrerror (h_errno));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not resolve our FQDN : %s\n"),
+                hstrerror (h_errno));
     return NULL;
   }
   return GNUNET_strdup (host->h_name);
@@ -919,13 +905,13 @@ GNUNET_RESOLVER_hostname_resolve (int domain,
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
-                         GNUNET_ERROR_TYPE_BULK, "gethostname");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "gethostname");
     return NULL;
   }
 #if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Resolving our hostname `%s'\n"), hostname);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolving our hostname `%s'\n"),
+              hostname);
 #endif
   return GNUNET_RESOLVER_ip_get (hostname, domain, timeout, callback, cls);
 }
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 9412457f6..844531b37 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -349,8 +349,7 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
  * @param timeout next timeout (updated)
  */
 static void
-update_sets (struct GNUNET_NETWORK_FDSet *rs,
-             struct GNUNET_NETWORK_FDSet *ws,
+update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
              struct GNUNET_TIME_Relative *timeout)
 {
   struct Task *pos;
@@ -434,8 +433,7 @@ set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
  * @return GNUNET_YES if we can run it, GNUNET_NO if not.
  */
 static int
-is_ready (struct Task *task,
-          struct GNUNET_TIME_Absolute now,
+is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
           const struct GNUNET_NETWORK_FDSet *rs,
           const struct GNUNET_NETWORK_FDSet *ws)
 {
@@ -525,8 +523,8 @@ check_ready (const struct GNUNET_NETWORK_FDSet *rs,
   {
 #if DEBUG_TASKS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Checking readiness of task: %llu / %p\n",
-                pos->id, pos->callback_cls);
+                "Checking readiness of task: %llu / %p\n", pos->id,
+                pos->callback_cls);
 #endif
     next = pos->next;
     if (GNUNET_YES == is_ready (pos, now, rs, ws))
@@ -657,11 +655,10 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
         DELAY_THRESHOLD.rel_value)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Task %llu took %llums to be scheduled\n",
-                  pos->id,
-                  (unsigned long long)
-                  GNUNET_TIME_absolute_get_duration
-                  (pos->start_time).rel_value);
+                  "Task %llu took %llums to be scheduled\n", pos->id,
+                  (unsigned long long) GNUNET_TIME_absolute_get_duration (pos->
+                                                                          start_time).
+                  rel_value);
     }
 #endif
     tc.reason = pos->reason;
@@ -678,17 +675,16 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
         (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
       abort ();                 // added to ready in previous select loop!
 #if DEBUG_TASKS
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Running task: %llu / %p\n", pos->id, pos->callback_cls);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running task: %llu / %p\n", pos->id,
+                pos->callback_cls);
 #endif
     pos->callback (pos->callback_cls, &tc);
 #if EXECINFO
     int i;
 
     for (i = 0; i < pos->num_backtrace_strings; i++)
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Task %llu trace %d: %s\n",
-                  pos->id, i, pos->backtrace_strings[i]);
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Task %llu trace %d: %s\n", pos->id,
+                  i, pos->backtrace_strings[i]);
 #endif
     active_task = NULL;
     destroy_task (pos);
@@ -809,8 +805,8 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
 #endif
   current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
   current_lifeness = GNUNET_YES;
-  GNUNET_SCHEDULER_add_continuation (task,
-                                     task_cls, GNUNET_SCHEDULER_REASON_STARTUP);
+  GNUNET_SCHEDULER_add_continuation (task, task_cls,
+                                     GNUNET_SCHEDULER_REASON_STARTUP);
 #if ENABLE_WINDOWS_WORKAROUNDS
   active_task = (void *) (long) -1;     /* force passing of sanity check */
   GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
@@ -1031,8 +1027,8 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
   }
   ret = t->callback_cls;
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Canceling task: %llu / %p\n", task, t->callback_cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task,
+              t->callback_cls);
 #endif
   destroy_task (t);
   return ret;
@@ -1049,8 +1045,7 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
  * @param reason reason for task invocation
  */
 void
-GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task,
-                                   void *task_cls,
+GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
                                    enum GNUNET_SCHEDULER_Reason reason)
 {
   struct Task *t;
@@ -1080,8 +1075,8 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task,
   t->priority = current_priority;
   t->lifeness = current_lifeness;
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding continuation task: %llu / %p\n", t->id, t->callback_cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n",
+              t->id, t->callback_cls);
 #endif
   queue_ready_task (t);
 }
@@ -1109,8 +1104,7 @@ GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
                             GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      prerequisite_task,
-                                      GNUNET_TIME_UNIT_ZERO,
+                                      prerequisite_task, GNUNET_TIME_UNIT_ZERO,
                                       NULL, NULL, task, task_cls);
 }
 
@@ -1128,10 +1122,9 @@ GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
                                     GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (prio,
-                                      GNUNET_SCHEDULER_NO_TASK,
-                                      GNUNET_TIME_UNIT_ZERO,
-                                      NULL, NULL, task, task_cls);
+  return GNUNET_SCHEDULER_add_select (prio, GNUNET_SCHEDULER_NO_TASK,
+                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                      task_cls);
 }
 
 
@@ -1212,23 +1205,23 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
   pending_timeout_last = t;
 
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding task: %llu / %p\n", t->id, t->callback_cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+              t->callback_cls);
 #endif
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+                t->backtrace_strings[i]);
 #endif
   return t->id;
 
 #else
   /* unoptimized version */
   return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      GNUNET_SCHEDULER_NO_TASK, delay,
-                                      NULL, NULL, task, task_cls);
+                                      GNUNET_SCHEDULER_NO_TASK, delay, NULL,
+                                      NULL, task, task_cls);
 #endif
 }
 
@@ -1248,8 +1241,8 @@ GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
                                       GNUNET_SCHEDULER_NO_TASK,
-                                      GNUNET_TIME_UNIT_ZERO,
-                                      NULL, NULL, task, task_cls);
+                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                      task_cls);
 }
 
 
@@ -1274,10 +1267,11 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 {
   GNUNET_SCHEDULER_TaskIdentifier ret;
 
-  ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                     GNUNET_SCHEDULER_NO_TASK,
-                                     GNUNET_TIME_UNIT_ZERO,
-                                     NULL, NULL, task, task_cls);
+  ret =
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                   task_cls);
   GNUNET_assert (pending->id == ret);
   pending->lifeness = lifeness;
   return ret;
@@ -1314,8 +1308,8 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
  */
 #ifndef MINGW
 GNUNET_SCHEDULER_TaskIdentifier
-add_without_sets (struct GNUNET_TIME_Relative delay,
-                  int rfd, int wfd, GNUNET_SCHEDULER_Task task, void *task_cls)
+add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
+                  GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
 
@@ -1346,8 +1340,8 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
       int i;
 
       for (i = 0; i < t->num_backtrace_strings; i++)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Trace: %s\n", t->backtrace_strings[i]);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n",
+                    t->backtrace_strings[i]);
 #endif
       GNUNET_assert (0);
     }
@@ -1364,8 +1358,8 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
       int i;
 
       for (i = 0; i < t->num_backtrace_strings; i++)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Trace: %s\n", t->backtrace_strings[i]);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n",
+                    t->backtrace_strings[i]);
 #endif
       GNUNET_assert (0);
     }
@@ -1386,15 +1380,15 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding task: %llu / %p\n", t->id, t->callback_cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+              t->callback_cls);
 #endif
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+                t->backtrace_strings[i]);
 #endif
   return t->id;
 }
@@ -1430,14 +1424,15 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
   GNUNET_assert (rfd != NULL);
   rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_set (rs, rfd);
-  ret = GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                     GNUNET_SCHEDULER_NO_TASK, delay,
-                                     rs, NULL, task, task_cls);
+  ret =
+      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+                                   GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
+                                   task, task_cls);
   GNUNET_NETWORK_fdset_destroy (rs);
   return ret;
 #else
-  return add_without_sets (delay,
-                           GNUNET_NETWORK_get_fd (rfd), -1, task, task_cls);
+  return add_without_sets (delay, GNUNET_NETWORK_get_fd (rfd), -1, task,
+                           task_cls);
 #endif
 }
 
@@ -1470,15 +1465,16 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
   GNUNET_assert (wfd != NULL);
   ws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_set (ws, wfd);
-  ret = GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                     GNUNET_SCHEDULER_NO_TASK, delay,
-                                     NULL, ws, task, task_cls);
+  ret =
+      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+                                   GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
+                                   task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
   return ret;
 #else
   GNUNET_assert (GNUNET_NETWORK_get_fd (wfd) >= 0);
-  return add_without_sets (delay,
-                           -1, GNUNET_NETWORK_get_fd (wfd), task, task_cls);
+  return add_without_sets (delay, -1, GNUNET_NETWORK_get_fd (wfd), task,
+                           task_cls);
 #endif
 }
 
@@ -1511,9 +1507,10 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
   GNUNET_assert (rfd != NULL);
   rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_handle_set (rs, rfd);
-  ret = GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                     GNUNET_SCHEDULER_NO_TASK, delay,
-                                     rs, NULL, task, task_cls);
+  ret =
+      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+                                   GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
+                                   task, task_cls);
   GNUNET_NETWORK_fdset_destroy (rs);
   return ret;
 #else
@@ -1554,9 +1551,10 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
   GNUNET_assert (wfd != NULL);
   ws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_handle_set (ws, wfd);
-  ret = GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                     GNUNET_SCHEDULER_NO_TASK,
-                                     delay, NULL, ws, task, task_cls);
+  ret =
+      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+                                   GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
+                                   task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
   return ret;
 #else
@@ -1605,8 +1603,7 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
-                             GNUNET_SCHEDULER_TaskIdentifier
-                             prerequisite_task,
+                             GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
                              struct GNUNET_TIME_Relative delay,
                              const struct GNUNET_NETWORK_FDSet *rs,
                              const struct GNUNET_NETWORK_FDSet *ws,
@@ -1648,22 +1645,22 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
   t->priority =
       check_priority ((prio ==
-                       GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority
-                      : prio);
+                       GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
+                      prio);
   t->lifeness = current_lifeness;
   t->next = pending;
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding task: %llu / %p\n", t->id, t->callback_cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+              t->callback_cls);
 #endif
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+                t->backtrace_strings[i]);
 #endif
   return t->id;
 }
diff --git a/src/util/server.c b/src/util/server.c
index 935cf04f8..504391bc7 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -381,9 +381,7 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
       if (port != 0)
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _
-                    ("`%s' failed for port %d (%s).\n"),
-                    "bind", port,
+                    _("`%s' failed for port %d (%s).\n"), "bind", port,
                     (serverAddr->sa_family == AF_INET) ? "IPv4" : "IPv6");
       eno = 0;
     }
@@ -391,15 +389,12 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
     {
       if (port != 0)
         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    _
-                    ("`%s' failed for port %d (%s): address already in use\n"),
+                    _("`%s' failed for port %d (%s): address already in use\n"),
                     "bind", port,
                     (serverAddr->sa_family == AF_INET) ? "IPv4" : "IPv6");
       else if (serverAddr->sa_family == AF_UNIX)
         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    _
-                    ("`%s' failed for `%s': address already in use\n"),
-                    "bind",
+                    _("`%s' failed for `%s': address already in use\n"), "bind",
                     ((const struct sockaddr_un *) serverAddr)->sun_path);
 
     }
@@ -483,12 +478,11 @@ GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
  *         (typically, "port" already in use)
  */
 struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access,
-                      void *access_cls,
+GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
                       struct sockaddr *const *serverAddr,
                       const socklen_t * socklen,
-                      struct GNUNET_TIME_Relative
-                      idle_timeout, int require_found)
+                      struct GNUNET_TIME_Relative idle_timeout,
+                      int require_found)
 {
   struct GNUNET_NETWORK_Handle **lsocks;
   unsigned int i;
@@ -521,8 +515,7 @@ GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access,
   {
     lsocks = NULL;
   }
-  return GNUNET_SERVER_create_with_sockets (access, access_cls,
-                                            lsocks,
+  return GNUNET_SERVER_create_with_sockets (access, access_cls, lsocks,
                                             idle_timeout, require_found);
 }
 
@@ -610,17 +603,17 @@ warn_no_receive_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_SERVER_Client *client = cls;
 
-  client->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                    &warn_no_receive_done,
-                                                    client);
+  client->warn_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                    &warn_no_receive_done, client);
   if (0 == (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _
                 ("Processing code for message of type %u did not call GNUNET_SERVER_receive_done after %llums\n"),
                 (unsigned int) client->warn_type,
-                (unsigned long long)
-                GNUNET_TIME_absolute_get_duration
-                (client->warn_start).rel_value);
+                (unsigned long long) GNUNET_TIME_absolute_get_duration (client->
+                                                                        warn_start).
+                rel_value);
 }
 
 
@@ -737,11 +730,9 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
  * @param addrlen length of addr
  * @param errCode code indicating errors receiving, 0 for success
  */
-static void
-process_incoming (void *cls,
-                  const void *buf,
-                  size_t available,
-                  const struct sockaddr *addr, socklen_t addrlen, int errCode);
+static void process_incoming (void *cls, const void *buf, size_t available,
+                              const struct sockaddr *addr, socklen_t addrlen,
+                              int errCode);
 
 
 /**
@@ -760,8 +751,7 @@ process_incoming (void *cls,
 static void
 process_mst (struct GNUNET_SERVER_Client *client, int ret)
 {
-  while ((ret != GNUNET_SYSERR) &&
-         (client->server != NULL) &&
+  while ((ret != GNUNET_SYSERR) && (client->server != NULL) &&
          (GNUNET_YES != client->shutdown_now) && (0 == client->suspended))
   {
     if (ret == GNUNET_OK)
@@ -774,8 +764,8 @@ process_mst (struct GNUNET_SERVER_Client *client, int ret)
 #endif
       GNUNET_CONNECTION_receive (client->connection,
                                  GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                                 client->idle_timeout,
-                                 &process_incoming, client);
+                                 client->idle_timeout, &process_incoming,
+                                 client);
       break;
     }
 #if DEBUG_SERVER
@@ -817,9 +807,7 @@ process_mst (struct GNUNET_SERVER_Client *client, int ret)
  * @param errCode code indicating errors receiving, 0 for success
  */
 static void
-process_incoming (void *cls,
-                  const void *buf,
-                  size_t available,
+process_incoming (void *cls, const void *buf, size_t available,
                   const struct sockaddr *addr, socklen_t addrlen, int errCode)
 {
   struct GNUNET_SERVER_Client *client = cls;
@@ -834,8 +822,7 @@ process_incoming (void *cls,
   end = GNUNET_TIME_absolute_add (client->last_activity, client->idle_timeout);
 
   if ((buf == NULL) && (available == 0) && (addr == NULL) && (errCode == 0) &&
-      (client->shutdown_now != GNUNET_YES) &&
-      (server != NULL) &&
+      (client->shutdown_now != GNUNET_YES) && (server != NULL) &&
       (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
       (end.abs_value > now.abs_value))
   {
@@ -852,10 +839,7 @@ process_incoming (void *cls,
                                &process_incoming, client);
     return;
   }
-  if ((buf == NULL) ||
-      (available == 0) ||
-      (errCode != 0) ||
-      (server == NULL) ||
+  if ((buf == NULL) || (available == 0) || (errCode != 0) || (server == NULL) ||
       (client->shutdown_now == GNUNET_YES) ||
       (GNUNET_YES != GNUNET_CONNECTION_check (client->connection)))
   {
@@ -864,8 +848,7 @@ process_incoming (void *cls,
     return;
   }
 #if DEBUG_SERVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Server receives %u bytes from `%s'.\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server receives %u bytes from `%s'.\n",
               (unsigned int) available, GNUNET_a2s (addr, addrlen));
 #endif
   GNUNET_SERVER_client_keep (client);
@@ -928,8 +911,7 @@ restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param message the actual message
  */
 static void
-client_message_tokenizer_callback (void *cls,
-                                   void *client,
+client_message_tokenizer_callback (void *cls, void *client,
                                    const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVER_Handle *server = cls;
@@ -963,17 +945,15 @@ client_message_tokenizer_callback (void *cls,
  *         "client_drop" on the return value eventually)
  */
 struct GNUNET_SERVER_Client *
-GNUNET_SERVER_connect_socket (struct
-                              GNUNET_SERVER_Handle
-                              *server,
+GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
                               struct GNUNET_CONNECTION_Handle *connection)
 {
   struct GNUNET_SERVER_Client *client;
 
   client = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Client));
   client->connection = connection;
-  client->mst = GNUNET_SERVER_mst_create (&client_message_tokenizer_callback,
-                                          server);
+  client->mst =
+      GNUNET_SERVER_mst_create (&client_message_tokenizer_callback, server);
   client->reference_count = 1;
   client->server = server;
   client->last_activity = GNUNET_TIME_absolute_get ();
@@ -1274,8 +1254,7 @@ GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
 {
   client->callback_cls = callback_cls;
   client->callback = callback;
-  return GNUNET_CONNECTION_notify_transmit_ready (client->connection,
-                                                  size,
+  return GNUNET_CONNECTION_notify_transmit_ready (client->connection, size,
                                                   timeout,
                                                   &transmit_ready_callback_wrapper,
                                                   client);
diff --git a/src/util/server_mst.c b/src/util/server_mst.c
index f48ef5475..07a7b30b8 100644
--- a/src/util/server_mst.c
+++ b/src/util/server_mst.c
@@ -119,9 +119,8 @@ GNUNET_SERVER_mst_create (GNUNET_SERVER_MessageTokenizerCallback cb,
  */
 int
 GNUNET_SERVER_mst_receive (struct GNUNET_SERVER_MessageStreamTokenizer *mst,
-                           void *client_identity,
-                           const char *buf,
-                           size_t size, int purge, int one_shot)
+                           void *client_identity, const char *buf, size_t size,
+                           int purge, int one_shot)
 {
   const struct GNUNET_MessageHeader *hdr;
   size_t delta;
diff --git a/src/util/server_nc.c b/src/util/server_nc.c
index f8e300029..a1cb43f00 100644
--- a/src/util/server_nc.c
+++ b/src/util/server_nc.c
@@ -323,10 +323,10 @@ transmit_message (void *cls, size_t size, void *buf)
                 "Have %u messages left in NC queue, will try transmission again\n",
                 cl->num_pending);
 #endif
-    cl->th = GNUNET_SERVER_notify_transmit_ready (cl->client,
-                                                  ntohs (pml->msg->size),
-                                                  GNUNET_TIME_UNIT_FOREVER_REL,
-                                                  &transmit_message, cl);
+    cl->th =
+        GNUNET_SERVER_notify_transmit_ready (cl->client, ntohs (pml->msg->size),
+                                             GNUNET_TIME_UNIT_FOREVER_REL,
+                                             &transmit_message, cl);
   }
   else
     GNUNET_assert (cl->num_pending == 0);
@@ -344,8 +344,8 @@ transmit_message (void *cls, size_t size, void *buf)
  */
 static void
 do_unicast (struct GNUNET_SERVER_NotificationContext *nc,
-            struct ClientList *client,
-            const struct GNUNET_MessageHeader *msg, int can_drop)
+            struct ClientList *client, const struct GNUNET_MessageHeader *msg,
+            int can_drop)
 {
   struct PendingMessageList *pml;
   uint16_t size;
@@ -354,8 +354,8 @@ do_unicast (struct GNUNET_SERVER_NotificationContext *nc,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Dropping message of type %u and size %u due to full queue (%u entries)\n",
-                ntohs (msg->type),
-                ntohs (msg->size), (unsigned int) nc->queue_length);
+                ntohs (msg->type), ntohs (msg->size),
+                (unsigned int) nc->queue_length);
     return;                     /* drop! */
   }
   if (client->num_pending > nc->queue_length)
@@ -371,21 +371,20 @@ do_unicast (struct GNUNET_SERVER_NotificationContext *nc,
 #if DEBUG_SERVER_NC
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Adding message of type %u and size %u to pending queue (which has %u entries)\n",
-              ntohs (msg->type),
-              ntohs (msg->size), (unsigned int) nc->queue_length);
+              ntohs (msg->type), ntohs (msg->size),
+              (unsigned int) nc->queue_length);
 #endif
   memcpy (&pml[1], msg, size);
   /* append */
-  GNUNET_CONTAINER_DLL_insert_tail (client->pending_head,
-                                    client->pending_tail, pml);
+  GNUNET_CONTAINER_DLL_insert_tail (client->pending_head, client->pending_tail,
+                                    pml);
   if (client->th == NULL)
-    client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
-                                                      ntohs
-                                                      (client->pending_head->
-                                                       msg->size),
-                                                      GNUNET_TIME_UNIT_FOREVER_REL,
-                                                      &transmit_message,
-                                                      client);
+    client->th =
+        GNUNET_SERVER_notify_transmit_ready (client->client,
+                                             ntohs (client->pending_head->msg->
+                                                    size),
+                                             GNUNET_TIME_UNIT_FOREVER_REL,
+                                             &transmit_message, client);
 }
 
 
diff --git a/src/util/server_tc.c b/src/util/server_tc.c
index eda82e50f..127131032 100644
--- a/src/util/server_tc.c
+++ b/src/util/server_tc.c
@@ -103,13 +103,13 @@ transmit_response (void *cls, size_t size, void *buf)
   }
   else
   {
-    if (NULL == GNUNET_SERVER_notify_transmit_ready (tc->client,
-                                                     GNUNET_MIN
-                                                     (MIN_BLOCK_SIZE,
-                                                      tc->total - tc->off),
-                                                     GNUNET_TIME_absolute_get_remaining
-                                                     (tc->timeout),
-                                                     &transmit_response, tc))
+    if (NULL ==
+        GNUNET_SERVER_notify_transmit_ready (tc->client,
+                                             GNUNET_MIN (MIN_BLOCK_SIZE,
+                                                         tc->total - tc->off),
+                                             GNUNET_TIME_absolute_get_remaining
+                                             (tc->timeout), &transmit_response,
+                                             tc))
     {
       GNUNET_break (0);
       GNUNET_SERVER_receive_done (tc->client, GNUNET_SYSERR);
diff --git a/src/util/service.c b/src/util/service.c
index 308267bd6..9b60dc56b 100644
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -99,12 +99,10 @@ parse_ipv4_specification (const char *routeList)
   pos = 0;
   while (i < count)
   {
-    cnt = sscanf (&routeList[pos],
-                  "%u.%u.%u.%u/%u.%u.%u.%u;",
-                  &temps[0],
-                  &temps[1],
-                  &temps[2],
-                  &temps[3], &temps[4], &temps[5], &temps[6], &temps[7]);
+    cnt =
+        sscanf (&routeList[pos], "%u.%u.%u.%u/%u.%u.%u.%u;", &temps[0],
+                &temps[1], &temps[2], &temps[3], &temps[4], &temps[5],
+                &temps[6], &temps[7]);
     if (cnt == 8)
     {
       for (j = 0; j < 8; j++)
@@ -115,8 +113,7 @@ parse_ipv4_specification (const char *routeList)
           GNUNET_free (result);
           return NULL;
         }
-      result[i].network.s_addr
-          =
+      result[i].network.s_addr =
           htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
                  temps[3]);
       result[i].netmask.s_addr =
@@ -129,9 +126,9 @@ parse_ipv4_specification (const char *routeList)
       continue;
     }
     /* try second notation */
-    cnt = sscanf (&routeList[pos],
-                  "%u.%u.%u.%u/%u;",
-                  &temps[0], &temps[1], &temps[2], &temps[3], &slash);
+    cnt =
+        sscanf (&routeList[pos], "%u.%u.%u.%u/%u;", &temps[0], &temps[1],
+                &temps[2], &temps[3], &slash);
     if (cnt == 5)
     {
       for (j = 0; j < 4; j++)
@@ -142,8 +139,7 @@ parse_ipv4_specification (const char *routeList)
           GNUNET_free (result);
           return NULL;
         }
-      result[i].network.s_addr
-          =
+      result[i].network.s_addr =
           htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
                  temps[3]);
       if ((slash <= 32) && (slash >= 0))
@@ -151,8 +147,8 @@ parse_ipv4_specification (const char *routeList)
         result[i].netmask.s_addr = 0;
         while (slash > 0)
         {
-          result[i].netmask.s_addr
-              = (result[i].netmask.s_addr >> 1) + 0x80000000;
+          result[i].netmask.s_addr =
+              (result[i].netmask.s_addr >> 1) + 0x80000000;
           slash--;
         }
         result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
@@ -174,8 +170,9 @@ parse_ipv4_specification (const char *routeList)
     }
     /* try third notation */
     slash = 32;
-    cnt = sscanf (&routeList[pos],
-                  "%u.%u.%u.%u;", &temps[0], &temps[1], &temps[2], &temps[3]);
+    cnt =
+        sscanf (&routeList[pos], "%u.%u.%u.%u;", &temps[0], &temps[1],
+                &temps[2], &temps[3]);
     if (cnt == 4)
     {
       for (j = 0; j < 4; j++)
@@ -186,8 +183,7 @@ parse_ipv4_specification (const char *routeList)
           GNUNET_free (result);
           return NULL;
         }
-      result[i].network.s_addr
-          =
+      result[i].network.s_addr =
           htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
                  temps[3]);
       result[i].netmask.s_addr = 0;
@@ -203,15 +199,15 @@ parse_ipv4_specification (const char *routeList)
       i++;
       continue;
     }
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Invalid format for IP: `%s'\n"), &routeList[pos]);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Invalid format for IP: `%s'\n"),
+                &routeList[pos]);
     GNUNET_free (result);
     return NULL;                /* error */
   }
   if (pos < strlen (routeList))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Invalid format for IP: `%s'\n"), &routeList[pos]);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Invalid format for IP: `%s'\n"),
+                &routeList[pos]);
     GNUNET_free (result);
     return NULL;                /* oops */
   }
@@ -259,8 +255,7 @@ parse_ipv6_specification (const char *routeListX)
   if (routeList[len - 1] != ';')
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _
-                ("Invalid network notation (does not end with ';': `%s')\n"),
+                _("Invalid network notation (does not end with ';': `%s')\n"),
                 routeList);
     GNUNET_free (routeList);
     return NULL;
@@ -313,8 +308,8 @@ parse_ipv6_specification (const char *routeListX)
         }
         while (bits > 0)
         {
-          result[i].netmask.s6_addr[off]
-              = (result[i].netmask.s6_addr[off] >> 1) + 0x80;
+          result[i].netmask.s6_addr[off] =
+              (result[i].netmask.s6_addr[off] >> 1) + 0x80;
           bits--;
         }
       }
@@ -550,16 +545,15 @@ write_test (void *cls, size_t size, void *buf)
  * @param message the actual message
  */
 static void
-handle_test (void *cls,
-             struct GNUNET_SERVER_Client *client,
+handle_test (void *cls, struct GNUNET_SERVER_Client *client,
              const struct GNUNET_MessageHeader *message)
 {
   /* simply bounce message back to acknowledge */
-  if (NULL == GNUNET_SERVER_notify_transmit_ready (client,
-                                                   sizeof (struct
-                                                           GNUNET_MessageHeader),
-                                                   GNUNET_TIME_UNIT_FOREVER_REL,
-                                                   &write_test, client))
+  if (NULL ==
+      GNUNET_SERVER_notify_transmit_ready (client,
+                                           sizeof (struct GNUNET_MessageHeader),
+                                           GNUNET_TIME_UNIT_FOREVER_REL,
+                                           &write_test, client))
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 }
 
@@ -591,8 +585,7 @@ static const struct GNUNET_SERVER_MessageHandler defhandlers[] = {
  *   for unknown address family (will be denied).
  */
 static int
-check_access (void *cls,
-              const struct GNUNET_CONNECTION_Credentials *uc,
+check_access (void *cls, const struct GNUNET_CONNECTION_Credentials *uc,
               const struct sockaddr *addr, socklen_t addrlen)
 {
   struct GNUNET_SERVICE_Context *sctx = cls;
@@ -606,19 +599,17 @@ check_access (void *cls,
     GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
     i4 = (const struct sockaddr_in *) addr;
     ret = ((sctx->v4_allowed == NULL) ||
-           (check_ipv4_listed (sctx->v4_allowed,
-                               &i4->sin_addr)))
-        && ((sctx->v4_denied == NULL) ||
-            (!check_ipv4_listed (sctx->v4_denied, &i4->sin_addr)));
+           (check_ipv4_listed (sctx->v4_allowed, &i4->sin_addr))) &&
+        ((sctx->v4_denied == NULL) ||
+         (!check_ipv4_listed (sctx->v4_denied, &i4->sin_addr)));
     break;
   case AF_INET6:
     GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
     i6 = (const struct sockaddr_in6 *) addr;
     ret = ((sctx->v6_allowed == NULL) ||
-           (check_ipv6_listed (sctx->v6_allowed,
-                               &i6->sin6_addr)))
-        && ((sctx->v6_denied == NULL) ||
-            (!check_ipv6_listed (sctx->v6_denied, &i6->sin6_addr)));
+           (check_ipv6_listed (sctx->v6_allowed, &i6->sin6_addr))) &&
+        ((sctx->v6_denied == NULL) ||
+         (!check_ipv6_listed (sctx->v6_denied, &i6->sin6_addr)));
     break;
 #ifndef WINDOWS
   case AF_UNIX:
@@ -626,11 +617,10 @@ check_access (void *cls,
     if ((sctx->match_uid == GNUNET_YES) || (sctx->match_gid == GNUNET_YES))
       ret = GNUNET_NO;
     if ((uc != NULL) &&
-        ((sctx->match_uid != GNUNET_YES) ||
-         (uc->uid == geteuid ()) ||
-         (uc->uid == getuid ())) &&
-        ((sctx->match_gid != GNUNET_YES) ||
-         (uc->gid == getegid ()) || (uc->gid == getgid ())))
+        ((sctx->match_uid != GNUNET_YES) || (uc->uid == geteuid ()) ||
+         (uc->uid == getuid ())) && ((sctx->match_gid != GNUNET_YES) ||
+                                     (uc->gid == getegid ()) ||
+                                     (uc->gid == getgid ())))
       ret = GNUNET_YES;
     else
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
@@ -639,8 +629,8 @@ check_access (void *cls,
     break;
 #endif
   default:
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Unknown address family %d\n"), addr->sa_family);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Unknown address family %d\n"),
+                addr->sa_family);
     return GNUNET_SYSERR;
   }
   if (ret != GNUNET_OK)
@@ -664,8 +654,7 @@ get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
   char *pif;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
-                                               sctx->serviceName,
+      GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, sctx->serviceName,
                                                "PIDFILE", &pif))
     return NULL;
   return pif;
@@ -676,8 +665,8 @@ get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
  * Parse an IPv4 access control list.
  */
 static int
-process_acl4 (struct IPv4NetworkSet **ret,
-              struct GNUNET_SERVICE_Context *sctx, const char *option)
+process_acl4 (struct IPv4NetworkSet **ret, struct GNUNET_SERVICE_Context *sctx,
+              const char *option)
 {
   char *opt;
 
@@ -705,8 +694,8 @@ process_acl4 (struct IPv4NetworkSet **ret,
  * Parse an IPv4 access control list.
  */
 static int
-process_acl6 (struct IPv6NetworkSet **ret,
-              struct GNUNET_SERVICE_Context *sctx, const char *option)
+process_acl6 (struct IPv6NetworkSet **ret, struct GNUNET_SERVICE_Context *sctx,
+              const char *option)
 {
   char *opt;
 
@@ -738,8 +727,8 @@ process_acl6 (struct IPv6NetworkSet **ret,
  * @param unixpath path to add
  */
 static void
-add_unixpath (struct sockaddr **saddrs,
-              socklen_t * saddrlens, const char *unixpath)
+add_unixpath (struct sockaddr **saddrs, socklen_t * saddrlens,
+              const char *unixpath)
 {
 #ifdef AF_UNIX
   struct sockaddr_un *un;
@@ -816,9 +805,8 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
   if (GNUNET_CONFIGURATION_have_value (cfg, serviceName, "DISABLEV6"))
   {
     if (GNUNET_SYSERR ==
-        (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                           serviceName,
-                                                           "DISABLEV6")))
+        (disablev6 =
+         GNUNET_CONFIGURATION_get_value_yesno (cfg, serviceName, "DISABLEV6")))
       return GNUNET_SYSERR;
   }
   else
@@ -830,8 +818,8 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
     desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
     if (NULL == desc)
     {
-      if ((errno == ENOBUFS) ||
-          (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
+      if ((errno == ENOBUFS) || (errno == ENOMEM) || (errno == ENFILE) ||
+          (errno == EACCES))
       {
         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
         return GNUNET_SYSERR;
@@ -853,8 +841,7 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
   if (GNUNET_CONFIGURATION_have_value (cfg, serviceName, "PORT"))
   {
     GNUNET_break (GNUNET_OK ==
-                  GNUNET_CONFIGURATION_get_value_number (cfg,
-                                                         serviceName,
+                  GNUNET_CONFIGURATION_get_value_number (cfg, serviceName,
                                                          "PORT", &port));
     if (port > 65535)
     {
@@ -869,8 +856,7 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
   if (GNUNET_CONFIGURATION_have_value (cfg, serviceName, "BINDTO"))
   {
     GNUNET_break (GNUNET_OK ==
-                  GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                         serviceName,
+                  GNUNET_CONFIGURATION_get_value_string (cfg, serviceName,
                                                          "BINDTO", &hostname));
   }
   else
@@ -878,11 +864,11 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
 
   unixpath = NULL;
 #ifdef AF_UNIX
-  if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (cfg,
-                                                      serviceName, "UNIXPATH"))
-      && (GNUNET_OK ==
-          GNUNET_CONFIGURATION_get_value_string (cfg, serviceName, "UNIXPATH",
-                                                 &unixpath)) &&
+  if ((GNUNET_YES ==
+       GNUNET_CONFIGURATION_have_value (cfg, serviceName, "UNIXPATH")) &&
+      (GNUNET_OK ==
+       GNUNET_CONFIGURATION_get_value_string (cfg, serviceName, "UNIXPATH",
+                                              &unixpath)) &&
       (0 < strlen (unixpath)))
   {
     /* probe UNIX support */
@@ -901,8 +887,8 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
     desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
     if (NULL == desc)
     {
-      if ((errno == ENOBUFS) ||
-          (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
+      if ((errno == ENOBUFS) || (errno == ENOMEM) || (errno == ENFILE) ||
+          (errno == EACCES))
       {
         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
         GNUNET_free_non_null (hostname);
@@ -955,11 +941,10 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
     memset (&hints, 0, sizeof (struct addrinfo));
     if (disablev6)
       hints.ai_family = AF_INET;
-    if ((0 != (ret = getaddrinfo (hostname,
-                                  NULL, &hints, &res))) || (res == NULL))
+    if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
+        (res == NULL))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to resolve `%s': %s\n"),
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to resolve `%s': %s\n"),
                   hostname, gai_strerror (ret));
       GNUNET_free (hostname);
       GNUNET_free_non_null (unixpath);
@@ -1006,8 +991,7 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
       if ((pos->ai_socktype != SOCK_STREAM) && (pos->ai_socktype != 0))
         continue;               /* huh? */
 #if DEBUG_SERVICE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Service `%s' will bind to `%s'\n",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service `%s' will bind to `%s'\n",
                   serviceName, GNUNET_a2s (pos->ai_addr, pos->ai_addrlen));
 #endif
       if (pos->ai_family == AF_INET)
@@ -1130,8 +1114,7 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
   if (GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->serviceName, "TIMEOUT"))
   {
     if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_time (sctx->cfg,
-                                             sctx->serviceName,
+        GNUNET_CONFIGURATION_get_value_time (sctx->cfg, sctx->serviceName,
                                              "TIMEOUT", &idleout))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -1144,13 +1127,13 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
   else
     sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
 
-  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
-                                       sctx->serviceName, "TOLERANT"))
+  if (GNUNET_CONFIGURATION_have_value
+      (sctx->cfg, sctx->serviceName, "TOLERANT"))
   {
     if (GNUNET_SYSERR ==
-        (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
-                                                          sctx->serviceName,
-                                                          "TOLERANT")))
+        (tolerant =
+         GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->serviceName,
+                                               "TOLERANT")))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _("Specified value for `%s' of service `%s' is invalid\n"),
@@ -1164,19 +1147,17 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
 #ifndef MINGW
   errno = 0;
   if ((NULL != (lpid = getenv ("LISTEN_PID"))) &&
-      (1 == sscanf (lpid, "%u", &pid)) &&
-      (getpid () == (pid_t) pid) &&
+      (1 == sscanf (lpid, "%u", &pid)) && (getpid () == (pid_t) pid) &&
       (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
-      (1 == sscanf (nfds, "%u", &cnt)) &&
-      (cnt > 0) && (cnt < FD_SETSIZE) && (cnt + 4 < FD_SETSIZE))
+      (1 == sscanf (nfds, "%u", &cnt)) && (cnt > 0) && (cnt < FD_SETSIZE) &&
+      (cnt + 4 < FD_SETSIZE))
   {
     sctx->lsocks =
         GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (cnt + 1));
     while (0 < cnt--)
     {
       flags = fcntl (3 + cnt, F_GETFD);
-      if ((flags < 0) ||
-          (0 != (flags & FD_CLOEXEC)) ||
+      if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) ||
           (NULL ==
            (sctx->lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
       {
@@ -1199,17 +1180,16 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
 
   if ((sctx->lsocks == NULL) &&
       (GNUNET_SYSERR ==
-       GNUNET_SERVICE_get_server_addresses (sctx->serviceName,
-                                            sctx->cfg,
+       GNUNET_SERVICE_get_server_addresses (sctx->serviceName, sctx->cfg,
                                             &sctx->addrs, &sctx->addrlens)))
     return GNUNET_SYSERR;
   sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
-  sctx->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
-                                                          sctx->serviceName,
-                                                          "UNIX_MATCH_UID");
-  sctx->match_gid = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
-                                                          sctx->serviceName,
-                                                          "UNIX_MATCH_GID");
+  sctx->match_uid =
+      GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->serviceName,
+                                            "UNIX_MATCH_UID");
+  sctx->match_gid =
+      GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->serviceName,
+                                            "UNIX_MATCH_GID");
   process_acl4 (&sctx->v4_denied, sctx, "REJECT_FROM");
   process_acl4 (&sctx->v4_allowed, sctx, "ACCEPT_FROM");
   process_acl6 (&sctx->v6_denied, sctx, "REJECT_FROM6");
@@ -1230,8 +1210,7 @@ get_user_name (struct GNUNET_SERVICE_Context *sctx)
   char *un;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
-                                               sctx->serviceName,
+      GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, sctx->serviceName,
                                                "USERNAME", &un))
     return NULL;
   return un;
@@ -1319,17 +1298,13 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   GNUNET_RESOLVER_connect (sctx->cfg);
   if (sctx->lsocks != NULL)
-    sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
-                                                      sctx,
-                                                      sctx->lsocks,
-                                                      sctx->timeout,
-                                                      sctx->require_found);
+    sctx->server =
+        GNUNET_SERVER_create_with_sockets (&check_access, sctx, sctx->lsocks,
+                                           sctx->timeout, sctx->require_found);
   else
-    sctx->server = GNUNET_SERVER_create (&check_access,
-                                         sctx,
-                                         sctx->addrs,
-                                         sctx->addrlens,
-                                         sctx->timeout, sctx->require_found);
+    sctx->server =
+        GNUNET_SERVER_create (&check_access, sctx, sctx->addrs, sctx->addrlens,
+                              sctx->timeout, sctx->require_found);
   if (sctx->server == NULL)
   {
     if (sctx->addrs != NULL)
@@ -1337,10 +1312,9 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       i = 0;
       while (sctx->addrs[i] != NULL)
       {
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                    _("Failed to start `%s' at `%s'\n"),
-                    sctx->serviceName,
-                    GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Failed to start `%s' at `%s'\n"),
+                    sctx->serviceName, GNUNET_a2s (sctx->addrs[i],
+                                                   sctx->addrlens[i]));
         i++;
       }
     }
@@ -1351,8 +1325,8 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   {
     /* install a task that will kill the server
      * process if the scheduler ever gets a shutdown signal */
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  &shutdown_task, sctx->server);
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
+                                  sctx->server);
   }
   sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
   memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
@@ -1372,10 +1346,9 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     i = 0;
     while (sctx->addrs[i] != NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Service `%s' runs at %s\n"),
-                  sctx->serviceName,
-                  GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Service `%s' runs at %s\n"),
+                  sctx->serviceName, GNUNET_a2s (sctx->addrs[i],
+                                                 sctx->addrlens[i]));
       i++;
     }
   }
@@ -1480,8 +1453,8 @@ set_user_id (struct GNUNET_SERVICE_Context *sctx)
   if (pws == NULL)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Cannot obtain information about user `%s': %s\n"),
-                user, errno == 0 ? _("No such user") : STRERROR (errno));
+                _("Cannot obtain information about user `%s': %s\n"), user,
+                errno == 0 ? _("No such user") : STRERROR (errno));
     GNUNET_free (user);
     return GNUNET_SYSERR;
   }
@@ -1537,11 +1510,9 @@ pid_file_delete (struct GNUNET_SERVICE_Context *sctx)
  *         if we shutdown nicely
  */
 int
-GNUNET_SERVICE_run (int argc,
-                    char *const *argv,
-                    const char *serviceName,
-                    enum GNUNET_SERVICE_Options opt,
-                    GNUNET_SERVICE_Main task, void *task_cls)
+GNUNET_SERVICE_run (int argc, char *const *argv, const char *serviceName,
+                    enum GNUNET_SERVICE_Options opt, GNUNET_SERVICE_Main task,
+                    void *task_cls)
 {
 #define HANDLE_ERROR do { err = 1; GNUNET_break (0); goto shutdown; } while (0)
 
@@ -1583,8 +1554,8 @@ GNUNET_SERVICE_run (int argc,
   sctx.serviceName = serviceName;
   sctx.cfg = cfg = GNUNET_CONFIGURATION_create ();
   /* setup subsystems */
-  if (GNUNET_SYSERR == GNUNET_GETOPT_run (serviceName, service_options, argc,
-                                          argv))
+  if (GNUNET_SYSERR ==
+      GNUNET_GETOPT_run (serviceName, service_options, argc, argv))
     goto shutdown;
   if (GNUNET_OK != GNUNET_log_setup (serviceName, loglev, logfile))
     HANDLE_ERROR;
@@ -1598,8 +1569,8 @@ GNUNET_SERVICE_run (int argc,
     goto shutdown;
 #if DEBUG_SERVICE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Service `%s' runs with configuration from `%s'\n",
-              serviceName, cfg_fn);
+              "Service `%s' runs with configuration from `%s'\n", serviceName,
+              cfg_fn);
 #endif
   if (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_number (sctx.cfg, "testing", "skew_offset",
@@ -1679,17 +1650,13 @@ GNUNET_SERVICE_start (const char *serviceName,
     return NULL;
   }
   if (sctx->lsocks != NULL)
-    sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
-                                                      sctx,
-                                                      sctx->lsocks,
-                                                      sctx->timeout,
-                                                      sctx->require_found);
+    sctx->server =
+        GNUNET_SERVER_create_with_sockets (&check_access, sctx, sctx->lsocks,
+                                           sctx->timeout, sctx->require_found);
   else
-    sctx->server = GNUNET_SERVER_create (&check_access,
-                                         sctx,
-                                         sctx->addrs,
-                                         sctx->addrlens,
-                                         sctx->timeout, sctx->require_found);
+    sctx->server =
+        GNUNET_SERVER_create (&check_access, sctx, sctx->addrs, sctx->addrlens,
+                              sctx->timeout, sctx->require_found);
 
   if (NULL == sctx->server)
   {
diff --git a/src/util/strings.c b/src/util/strings.c
index a95981690..e2ca69e10 100644
--- a/src/util/strings.c
+++ b/src/util/strings.c
@@ -96,8 +96,8 @@ GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...)
  *         in the buffer, or 0 on error.
  */
 unsigned int
-GNUNET_STRINGS_buffer_tokenize (const char *buffer,
-                                size_t size, unsigned int count, ...)
+GNUNET_STRINGS_buffer_tokenize (const char *buffer, size_t size,
+                                unsigned int count, ...)
 {
   unsigned int start;
   unsigned int needed;
@@ -314,8 +314,7 @@ GNUNET_STRINGS_filename_expand (const char *fil)
   }
   n = strlen (fm) + 1 + strlen (fil_ptr) + 1;
   buffer = GNUNET_malloc (n);
-  GNUNET_snprintf (buffer, n, "%s%s%s",
-                   fm,
+  GNUNET_snprintf (buffer, n, "%s%s%s", fm,
                    (fm[strlen (fm) - 1] ==
                     DIR_SEPARATOR) ? "" : DIR_SEPARATOR_STR, fil_ptr);
   GNUNET_free (fm);
diff --git a/src/util/test_client.c b/src/util/test_client.c
index 9c2abb016..f9d961ab6 100644
--- a/src/util/test_client.c
+++ b/src/util/test_client.c
@@ -70,8 +70,7 @@ copy_msg (void *cls, size_t size, void *buf)
  * Callback that just bounces the message back to the sender.
  */
 static void
-echo_cb (void *cls,
-         struct GNUNET_SERVER_Client *client,
+echo_cb (void *cls, struct GNUNET_SERVER_Client *client,
          const struct GNUNET_MessageHeader *message)
 {
   struct CopyContext *cc;
@@ -148,13 +147,10 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #endif
   sa.sin_family = AF_INET;
   sa.sin_port = htons (PORT);
-  server = GNUNET_SERVER_create (NULL,
-                                 NULL,
-                                 sap,
-                                 slens,
-                                 GNUNET_TIME_relative_multiply
-                                 (GNUNET_TIME_UNIT_MILLISECONDS, 10000),
-                                 GNUNET_NO);
+  server =
+      GNUNET_SERVER_create (NULL, NULL, sap, slens,
+                            GNUNET_TIME_relative_multiply
+                            (GNUNET_TIME_UNIT_MILLISECONDS, 10000), GNUNET_NO);
   GNUNET_assert (server != NULL);
   handlers[0].callback_cls = cls;
   handlers[1].callback_cls = cls;
@@ -166,8 +162,8 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                                       sizeof (struct
                                                               GNUNET_MessageHeader),
                                                       GNUNET_TIME_UNIT_SECONDS,
-                                                      GNUNET_NO,
-                                                      &make_msg, NULL));
+                                                      GNUNET_NO, &make_msg,
+                                                      NULL));
   GNUNET_CLIENT_receive (client, &recv_bounce, cls,
                          GNUNET_TIME_relative_multiply
                          (GNUNET_TIME_UNIT_MILLISECONDS, 10000));
@@ -186,8 +182,8 @@ check ()
   cfg = GNUNET_CONFIGURATION_create ();
   GNUNET_CONFIGURATION_set_value_number (cfg, MYNAME, "PORT", PORT);
   GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "HOSTNAME", "localhost");
-  GNUNET_CONFIGURATION_set_value_string (cfg,
-                                         "resolver", "HOSTNAME", "localhost");
+  GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
+                                         "localhost");
   ok = 1;
   GNUNET_SCHEDULER_run (&task, &ok);
   GNUNET_CONFIGURATION_destroy (cfg);
diff --git a/src/util/test_common_endian.c b/src/util/test_common_endian.c
index fb556c7f4..a709abec6 100644
--- a/src/util/test_common_endian.c
+++ b/src/util/test_common_endian.c
@@ -33,8 +33,8 @@ main (int argc, char *argv[])
   CHECK (1);
   CHECK (0x12345678);
   CHECK (123456789012345LL);
-  if ((0x1234567890ABCDEFLL !=
-       GNUNET_htonll (0xEFCDAB9078563412LL)) && 42 != htonl (42))
+  if ((0x1234567890ABCDEFLL != GNUNET_htonll (0xEFCDAB9078563412LL)) &&
+      42 != htonl (42))
     return 1;
   return 0;
 }
diff --git a/src/util/test_common_logging.c b/src/util/test_common_logging.c
index da200d62a..39ef58267 100644
--- a/src/util/test_common_logging.c
+++ b/src/util/test_common_logging.c
@@ -27,8 +27,8 @@
 #include "gnunet_common.h"
 
 static void
-my_log (void *ctx, enum GNUNET_ErrorType kind,
-        const char *component, const char *date, const char *msg)
+my_log (void *ctx, enum GNUNET_ErrorType kind, const char *component,
+        const char *date, const char *msg)
 {
   unsigned int *c = ctx;
 
diff --git a/src/util/test_configuration.c b/src/util/test_configuration.c
index 8bad5b5d4..2737cb4f7 100644
--- a/src/util/test_configuration.c
+++ b/src/util/test_configuration.c
@@ -75,8 +75,8 @@ initDiffsCBData (struct DiffsCBData *cbData)
  * and comparing configuration
 */
 static void
-diffsCallBack (void *cls,
-               const char *section, const char *option, const char *value)
+diffsCallBack (void *cls, const char *section, const char *option,
+               const char *value)
 {
   struct DiffsCBData *cbData = cls;
   int cbOption = cbData->callBackOption;
@@ -90,15 +90,15 @@ diffsCallBack (void *cls,
     {
       GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, option,
                                              "new-value");
-      GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section,
-                                             option, "new-value");
+      GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section, option,
+                                             "new-value");
     }
     break;
   case EDIT_ALL:
     GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, option,
                                            "new-value");
-    GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section,
-                                           option, "new-value");
+    GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section, option,
+                                           "new-value");
     break;
   case ADD_NEW_ENTRY:
   {
@@ -107,8 +107,8 @@ diffsCallBack (void *cls,
     if (hit == 0)
     {
       hit = 1;
-      GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section,
-                                             "new-key", "new-value");
+      GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, "new-key",
+                                             "new-value");
       GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section,
                                              "new-key", "new-value");
     }
@@ -183,8 +183,8 @@ editConfiguration (struct GNUNET_CONFIGURATION_Handle *cfg, int option)
       GNUNET_asprintf (&key, "key%d", i);
       GNUNET_CONFIGURATION_set_value_string (cfg, "new-section", key,
                                              "new-value");
-      GNUNET_CONFIGURATION_set_value_string (diffsCB.cfgDiffs,
-                                             "new-section", key, "new-value");
+      GNUNET_CONFIGURATION_set_value_string (diffsCB.cfgDiffs, "new-section",
+                                             key, "new-value");
       GNUNET_free (key);
     }
     break;
@@ -282,8 +282,8 @@ testConfig ()
     return 2;
   }
   GNUNET_free (c);
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
-                                                          "test", "five", &l))
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg, "test", "five", &l))
   {
     GNUNET_break (0);
     return 3;
@@ -364,9 +364,9 @@ testConfigFilenames ()
   int idx;
 
   idx = 0;
-  if (3 != GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
-                                                         "FILENAMES",
-                                                         "test", &check, &idx))
+  if (3 !=
+      GNUNET_CONFIGURATION_iterate_value_filenames (cfg, "FILENAMES", "test",
+                                                    &check, &idx))
   {
     GNUNET_break (0);
     return 8;
@@ -374,60 +374,54 @@ testConfigFilenames ()
   if (idx != 3)
     return 16;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_remove_value_filename (cfg,
-                                                  "FILENAMES",
-                                                  "test", "/File Name"))
+      GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
+                                                  "/File Name"))
   {
     GNUNET_break (0);
     return 24;
   }
 
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_remove_value_filename (cfg,
-                                                  "FILENAMES",
-                                                  "test", "/File Name"))
+      GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
+                                                  "/File Name"))
   {
     GNUNET_break (0);
     return 32;
   }
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_remove_value_filename (cfg,
-                                                  "FILENAMES", "test", "Stuff"))
+      GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
+                                                  "Stuff"))
   {
     GNUNET_break (0);
     return 40;
   }
 
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg,
-                                                  "FILENAMES",
-                                                  "test", "/Hello"))
+      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
+                                                  "/Hello"))
   {
     GNUNET_break (0);
     return 48;
   }
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg,
-                                                  "FILENAMES",
-                                                  "test", "/World"))
+      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
+                                                  "/World"))
   {
     GNUNET_break (0);
     return 56;
   }
 
   if (GNUNET_YES !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg,
-                                                  "FILENAMES",
-                                                  "test", "/File 1"))
+      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
+                                                  "/File 1"))
   {
     GNUNET_break (0);
     return 64;
   }
 
   if (GNUNET_YES !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg,
-                                                  "FILENAMES",
-                                                  "test", "/File 2"))
+      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
+                                                  "/File 2"))
   {
     GNUNET_break (0);
     return 72;
@@ -437,9 +431,9 @@ testConfigFilenames ()
   want[1] = "/World";
   want[2] = "/File 1";
   want[3] = "/File 2";
-  if (4 != GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
-                                                         "FILENAMES",
-                                                         "test", &check, &idx))
+  if (4 !=
+      GNUNET_CONFIGURATION_iterate_value_filenames (cfg, "FILENAMES", "test",
+                                                    &check, &idx))
   {
     GNUNET_break (0);
     return 80;
diff --git a/src/util/test_connection.c b/src/util/test_connection.c
index 3519522ef..cb69f4036 100644
--- a/src/util/test_connection.c
+++ b/src/util/test_connection.c
@@ -75,9 +75,7 @@ open_listen_socket ()
 }
 
 static void
-receive_check (void *cls,
-               const void *buf,
-               size_t available,
+receive_check (void *cls, const void *buf, size_t available,
                const struct sockaddr *addr, socklen_t addrlen, int errCode)
 {
   int *ok = cls;
@@ -93,11 +91,10 @@ receive_check (void *cls,
 #if VERBOSE
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receive needs more data\n");
 #endif
-    GNUNET_CONNECTION_receive (asock,
-                               1024,
+    GNUNET_CONNECTION_receive (asock, 1024,
                                GNUNET_TIME_relative_multiply
-                               (GNUNET_TIME_UNIT_SECONDS, 5),
-                               &receive_check, cls);
+                               (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
+                               cls);
   }
   else
   {
@@ -127,8 +124,7 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Test asks to receive on accepted socket\n");
 #endif
-  GNUNET_CONNECTION_receive (asock,
-                             1024,
+  GNUNET_CONNECTION_receive (asock, 1024,
                              GNUNET_TIME_relative_multiply
                              (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
                              cls);
@@ -162,15 +158,14 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test asks for write notification\n");
 #endif
   GNUNET_assert (NULL !=
-                 GNUNET_CONNECTION_notify_transmit_ready (csock,
-                                                          12,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock, 12,
                                                           GNUNET_TIME_UNIT_SECONDS,
                                                           &make_hello, NULL));
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n");
 #endif
-  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                 ls, &run_accept, cls);
+  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, ls, &run_accept,
+                                 cls);
 }
 
 
@@ -185,8 +180,8 @@ check ()
 
   ok = 1;
   cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_CONFIGURATION_set_value_string (cfg,
-                                         "resolver", "HOSTNAME", "localhost");
+  GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
+                                         "localhost");
   GNUNET_SCHEDULER_run (&task, &ok);
   GNUNET_CONFIGURATION_destroy (cfg);
   return ok;
diff --git a/src/util/test_connection_addressing.c b/src/util/test_connection_addressing.c
index 111894a36..2d08acc3c 100644
--- a/src/util/test_connection_addressing.c
+++ b/src/util/test_connection_addressing.c
@@ -67,9 +67,9 @@ open_listen_socket ()
   if (GNUNET_NETWORK_socket_setsockopt
       (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "setsockopt");
-  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (desc,
-                                               (const struct sockaddr *) &sa,
-                                               sizeof (sa)))
+  if (GNUNET_OK !=
+      GNUNET_NETWORK_socket_bind (desc, (const struct sockaddr *) &sa,
+                                  sizeof (sa)))
   {
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                          "bind");
@@ -81,9 +81,7 @@ open_listen_socket ()
 
 
 static void
-receive_check (void *cls,
-               const void *buf,
-               size_t available,
+receive_check (void *cls, const void *buf, size_t available,
                const struct sockaddr *addr, socklen_t addrlen, int errCode)
 {
   int *ok = cls;
@@ -93,11 +91,10 @@ receive_check (void *cls,
     sofar += available;
   if (sofar < 12)
   {
-    GNUNET_CONNECTION_receive (asock,
-                               1024,
+    GNUNET_CONNECTION_receive (asock, 1024,
                                GNUNET_TIME_relative_multiply
-                               (GNUNET_TIME_UNIT_SECONDS, 5),
-                               &receive_check, cls);
+                               (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
+                               cls);
   }
   else
   {
@@ -132,8 +129,7 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (0 == memcmp (&expect, v4, alen));
   GNUNET_free (addr);
   GNUNET_CONNECTION_destroy (lsock, GNUNET_YES);
-  GNUNET_CONNECTION_receive (asock,
-                             1024,
+  GNUNET_CONNECTION_receive (asock, 1024,
                              GNUNET_TIME_relative_multiply
                              (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
                              cls);
@@ -162,18 +158,18 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   v4.sin_family = AF_INET;
   v4.sin_port = htons (PORT);
   v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-  csock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET,
-                                                  (const struct sockaddr
-                                                   *) &v4, sizeof (v4));
+  csock =
+      GNUNET_CONNECTION_create_from_sockaddr (AF_INET,
+                                              (const struct sockaddr *) &v4,
+                                              sizeof (v4));
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
-                 GNUNET_CONNECTION_notify_transmit_ready (csock,
-                                                          12,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock, 12,
                                                           GNUNET_TIME_UNIT_SECONDS,
                                                           &make_hello, NULL));
   GNUNET_CONNECTION_destroy (csock, GNUNET_YES);
-  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                 ls, &run_accept, cls);
+  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, ls, &run_accept,
+                                 cls);
 }
 
 
diff --git a/src/util/test_connection_receive_cancel.c b/src/util/test_connection_receive_cancel.c
index d635f5742..aa1672455 100644
--- a/src/util/test_connection_receive_cancel.c
+++ b/src/util/test_connection_receive_cancel.c
@@ -76,9 +76,7 @@ open_listen_socket ()
 
 
 static void
-dead_receive (void *cls,
-              const void *buf,
-              size_t available,
+dead_receive (void *cls, const void *buf, size_t available,
               const struct sockaddr *addr, socklen_t addrlen, int errCode)
 {
   GNUNET_assert (0);
@@ -93,8 +91,7 @@ run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (asock != NULL);
   GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
   GNUNET_CONNECTION_destroy (lsock, GNUNET_YES);
-  GNUNET_CONNECTION_receive (asock,
-                             1024,
+  GNUNET_CONNECTION_receive (asock, 1024,
                              GNUNET_TIME_relative_multiply
                              (GNUNET_TIME_UNIT_SECONDS, 5), &dead_receive, cls);
 }
@@ -121,10 +118,10 @@ task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (lsock != NULL);
   csock = GNUNET_CONNECTION_create_from_connect (cfg, "localhost", PORT);
   GNUNET_assert (csock != NULL);
-  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                 ls, &run_accept_cancel, cls);
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                &receive_cancel_task, cls);
+  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, ls,
+                                 &run_accept_cancel, cls);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &receive_cancel_task,
+                                cls);
 }
 
 
@@ -139,8 +136,8 @@ check_receive_cancel ()
 
   ok = 1;
   cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_CONFIGURATION_set_value_string (cfg,
-                                         "resolver", "HOSTNAME", "localhost");
+  GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
+                                         "localhost");
   GNUNET_SCHEDULER_run (&task_receive_cancel, &ok);
   GNUNET_CONFIGURATION_destroy (cfg);
   return ok;
diff --git a/src/util/test_connection_timeout.c b/src/util/test_connection_timeout.c
index 3989d654a..2338665cb 100644
--- a/src/util/test_connection_timeout.c
+++ b/src/util/test_connection_timeout.c
@@ -94,8 +94,7 @@ send_kilo (void *cls, size_t size, void *buf)
   memset (buf, 42, 1024);
 
   GNUNET_assert (NULL !=
-                 GNUNET_CONNECTION_notify_transmit_ready (csock,
-                                                          1024,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock, 1024,
                                                           GNUNET_TIME_UNIT_SECONDS,
                                                           &send_kilo, cls));
   return 1024;
@@ -112,8 +111,7 @@ task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   csock = GNUNET_CONNECTION_create_from_connect (cfg, "localhost", PORT);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
-                 GNUNET_CONNECTION_notify_transmit_ready (csock,
-                                                          1024,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock, 1024,
                                                           GNUNET_TIME_UNIT_SECONDS,
                                                           &send_kilo, cls));
 }
@@ -130,8 +128,8 @@ check_timeout ()
 
   ok = 1;
   cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_CONFIGURATION_set_value_string (cfg,
-                                         "resolver", "HOSTNAME", "localhost");
+  GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
+                                         "localhost");
   GNUNET_SCHEDULER_run (&task_timeout, &ok);
   GNUNET_CONFIGURATION_destroy (cfg);
   return ok;
diff --git a/src/util/test_connection_timeout_no_connect.c b/src/util/test_connection_timeout_no_connect.c
index ea4a32412..2e8f9be2e 100644
--- a/src/util/test_connection_timeout_no_connect.c
+++ b/src/util/test_connection_timeout_no_connect.c
@@ -57,8 +57,7 @@ task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   csock = GNUNET_CONNECTION_create_from_connect (cfg, "localhost", PORT);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
-                 GNUNET_CONNECTION_notify_transmit_ready (csock,
-                                                          1024,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock, 1024,
                                                           GNUNET_TIME_UNIT_SECONDS,
                                                           &handle_timeout,
                                                           cls));
@@ -76,8 +75,8 @@ check_timeout ()
 
   ok = 1;
   cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_CONFIGURATION_set_value_string (cfg,
-                                         "resolver", "HOSTNAME", "localhost");
+  GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
+                                         "localhost");
   GNUNET_SCHEDULER_run (&task_timeout, &ok);
   GNUNET_CONFIGURATION_destroy (cfg);
   return ok;
diff --git a/src/util/test_connection_transmit_cancel.c b/src/util/test_connection_transmit_cancel.c
index 4280edf1d..d81c32a6c 100644
--- a/src/util/test_connection_transmit_cancel.c
+++ b/src/util/test_connection_transmit_cancel.c
@@ -51,8 +51,7 @@ task_transmit_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   csock = GNUNET_CONNECTION_create_from_connect (cfg, "localhost", PORT);
   GNUNET_assert (csock != NULL);
-  th = GNUNET_CONNECTION_notify_transmit_ready (csock,
-                                                12,
+  th = GNUNET_CONNECTION_notify_transmit_ready (csock, 12,
                                                 GNUNET_TIME_UNIT_MINUTES,
                                                 &not_run, cls);
   GNUNET_assert (NULL != th);
@@ -74,8 +73,8 @@ check_transmit_cancel ()
 
   ok = 1;
   cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_CONFIGURATION_set_value_string (cfg,
-                                         "resolver", "HOSTNAME", "localhost");
+  GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
+                                         "localhost");
   GNUNET_SCHEDULER_run (&task_transmit_cancel, &ok);
   GNUNET_CONFIGURATION_destroy (cfg);
   return ok;
diff --git a/src/util/test_container_bloomfilter.c b/src/util/test_container_bloomfilter.c
index 49cddac7c..c14adb075 100644
--- a/src/util/test_container_bloomfilter.c
+++ b/src/util/test_container_bloomfilter.c
@@ -127,8 +127,8 @@ main (int argc, char *argv[])
 
   if (ok2 != 200)
   {
-    printf ("Got %d elements out of 200 "
-            "expected after initialization.\n", ok2);
+    printf ("Got %d elements out of 200 " "expected after initialization.\n",
+            ok2);
     GNUNET_CONTAINER_bloomfilter_free (bf);
     GNUNET_CONTAINER_bloomfilter_free (bfi);
     return -1;
diff --git a/src/util/test_container_heap.c b/src/util/test_container_heap.c
index 7b352241c..62d675bbb 100644
--- a/src/util/test_container_heap.c
+++ b/src/util/test_container_heap.c
@@ -29,8 +29,7 @@
 #include "gnunet_container_lib.h"
 
 static int
-iterator_callback (void *cls,
-                   struct GNUNET_CONTAINER_HeapNode *node,
+iterator_callback (void *cls, struct GNUNET_CONTAINER_HeapNode *node,
                    void *element, GNUNET_CONTAINER_HeapCostType cost)
 {
   return GNUNET_OK;
diff --git a/src/util/test_container_meta_data.c b/src/util/test_container_meta_data.c
index cee550f96..fe1dd79c1 100644
--- a/src/util/test_container_meta_data.c
+++ b/src/util/test_container_meta_data.c
@@ -41,20 +41,17 @@ testMeta (int i)
 
   m = GNUNET_CONTAINER_meta_data_create ();
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m,
-                                         "<test>",
-                                         EXTRACTOR_METATYPE_TITLE,
+      GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE,
                                          EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain",
-                                         "TestTitle", strlen ("TestTitle") + 1))
+                                         "text/plain", "TestTitle",
+                                         strlen ("TestTitle") + 1))
     ABORT (m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m,
-                                         "<test>",
+      GNUNET_CONTAINER_meta_data_insert (m, "<test>",
                                          EXTRACTOR_METATYPE_AUTHOR_NAME,
                                          EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain",
-                                         "TestTitle", strlen ("TestTitle") + 1))
+                                         "text/plain", "TestTitle",
+                                         strlen ("TestTitle") + 1))
     ABORT (m);
   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))   /* dup! */
     ABORT (m);
@@ -63,8 +60,7 @@ testMeta (int i)
   if (2 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
     ABORT (m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_delete (m,
-                                         EXTRACTOR_METATYPE_AUTHOR_NAME,
+      GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME,
                                          "TestTitle", strlen ("TestTitle") + 1))
     ABORT (m);
   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME, "TestTitle", strlen ("TestTitle") + 1))        /* already gone */
@@ -72,8 +68,7 @@ testMeta (int i)
   if (1 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
     ABORT (m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_delete (m,
-                                         EXTRACTOR_METATYPE_TITLE,
+      GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE,
                                          "TestTitle", strlen ("TestTitle") + 1))
     ABORT (m);
   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE, "TestTitle", strlen ("TestTitle") + 1))      /* already gone */
@@ -82,12 +77,10 @@ testMeta (int i)
     ABORT (m);
   for (j = 0; j < i; j++)
   {
-    GNUNET_snprintf (val,
-                     sizeof (val),
-                     "%s.%d", "A teststring that should compress well.", j);
+    GNUNET_snprintf (val, sizeof (val), "%s.%d",
+                     "A teststring that should compress well.", j);
     if (GNUNET_OK !=
-        GNUNET_CONTAINER_meta_data_insert (m,
-                                           "<test>",
+        GNUNET_CONTAINER_meta_data_insert (m, "<test>",
                                            EXTRACTOR_METATYPE_UNKNOWN,
                                            EXTRACTOR_METAFORMAT_UTF8,
                                            "text/plain", val, strlen (val) + 1))
@@ -98,9 +91,9 @@ testMeta (int i)
 
   size = GNUNET_CONTAINER_meta_data_get_serialized_size (m);
   sval = NULL;
-  if (size != GNUNET_CONTAINER_meta_data_serialize (m,
-                                                    &sval, size,
-                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
+  if (size !=
+      GNUNET_CONTAINER_meta_data_serialize (m, &sval, size,
+                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
   {
     GNUNET_free_non_null (sval);
     ABORT (m);
@@ -112,13 +105,11 @@ testMeta (int i)
     ABORT (m);
   for (j = 0; j < i; j++)
   {
-    GNUNET_snprintf (val,
-                     sizeof (val), "%s.%d",
+    GNUNET_snprintf (val, sizeof (val), "%s.%d",
                      "A teststring that should compress well.", j);
     if (GNUNET_OK !=
-        GNUNET_CONTAINER_meta_data_delete (m,
-                                           EXTRACTOR_METATYPE_UNKNOWN,
-                                           val, strlen (val) + 1))
+        GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_UNKNOWN, val,
+                                           strlen (val) + 1))
     {
       ABORT (m);
     }
@@ -142,17 +133,16 @@ testMetaMore (int i)
   for (q = 0; q <= i; q++)
   {
     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
-    GNUNET_CONTAINER_meta_data_insert (meta,
-                                       "<test>",
+    GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
                                        q % EXTRACTOR_metatype_get_max (),
-                                       EXTRACTOR_METAFORMAT_UTF8,
-                                       "text/plain", txt, strlen (txt) + 1);
+                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                       txt, strlen (txt) + 1);
   }
   size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
   data = GNUNET_malloc (size * 4);
-  if (size != GNUNET_CONTAINER_meta_data_serialize (meta,
-                                                    &data, size * 4,
-                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
+  if (size !=
+      GNUNET_CONTAINER_meta_data_serialize (meta, &data, size * 4,
+                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
   {
     GNUNET_free (data);
     ABORT (meta);
@@ -171,25 +161,23 @@ testMetaLink ()
 
   m = GNUNET_CONTAINER_meta_data_create ();
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m,
-                                         "<test>",
+      GNUNET_CONTAINER_meta_data_insert (m, "<test>",
                                          EXTRACTOR_METATYPE_UNKNOWN,
                                          EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain",
-                                         "link", strlen ("link") + 1))
+                                         "text/plain", "link",
+                                         strlen ("link") + 1))
     ABORT (m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m,
-                                         "<test>",
+      GNUNET_CONTAINER_meta_data_insert (m, "<test>",
                                          EXTRACTOR_METATYPE_FILENAME,
                                          EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain",
-                                         "lib-link.m4",
+                                         "text/plain", "lib-link.m4",
                                          strlen ("lib-link.m4") + 1))
     ABORT (m);
   val = NULL;
-  size = GNUNET_CONTAINER_meta_data_serialize (m, &val, (size_t) - 1,
-                                               GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  size =
+      GNUNET_CONTAINER_meta_data_serialize (m, &val, (size_t) - 1,
+                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   GNUNET_CONTAINER_meta_data_destroy (m);
   m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
   GNUNET_free (val);
@@ -215,17 +203,13 @@ check ()
   for (q = 0; q <= i; q++)
   {
     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
-    GNUNET_CONTAINER_meta_data_insert (meta,
-                                       "<test>",
+    GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
                                        EXTRACTOR_METATYPE_UNKNOWN,
-                                       EXTRACTOR_METAFORMAT_UTF8,
-                                       "text/plain",
+                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
                                        "TestTitle", strlen ("TestTitle") + 1);
-    GNUNET_CONTAINER_meta_data_insert (meta2,
-                                       "<test>",
+    GNUNET_CONTAINER_meta_data_insert (meta2, "<test>",
                                        EXTRACTOR_METATYPE_UNKNOWN,
-                                       EXTRACTOR_METAFORMAT_UTF8,
-                                       "text/plain",
+                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
                                        "TestTitle", strlen ("TestTitle") + 1);
   }
 
@@ -303,9 +287,10 @@ check ()
   }
 
   //check meta_data_get_first_by_types
-  str = GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
-                                                       EXTRACTOR_METATYPE_UNKNOWN,
-                                                       -1);
+  str =
+      GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
+                                                     EXTRACTOR_METATYPE_UNKNOWN,
+                                                     -1);
   GNUNET_assert (NULL != str);
   if (str[0] != 'T')
   {
diff --git a/src/util/test_container_multihashmap.c b/src/util/test_container_multihashmap.c
index c16b2df22..ba621c17e 100644
--- a/src/util/test_container_multihashmap.c
+++ b/src/util/test_container_multihashmap.c
@@ -54,27 +54,23 @@ testMap (int i)
   CHECK (0 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
   CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
 
-  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
-                                                         &k1,
-                                                         "v1",
-                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK (GNUNET_OK ==
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
   CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
   ret = GNUNET_CONTAINER_multihashmap_get (m, &k1);
   GNUNET_assert (ret != NULL);
   CHECK (0 == strcmp ("v1", ret));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_put (m,
-                                                         &k1,
-                                                         "v1",
-                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK (GNUNET_NO ==
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
   CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
-                                                         &k1,
-                                                         "v2",
-                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
-                                                         &k1,
-                                                         "v3",
-                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK (GNUNET_OK ==
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK (GNUNET_OK ==
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v3",
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
   CHECK (3 == GNUNET_CONTAINER_multihashmap_size (m));
   CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (m, &k1, "v3"));
   CHECK (2 == GNUNET_CONTAINER_multihashmap_size (m));
@@ -85,10 +81,9 @@ testMap (int i)
   CHECK (2 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
   CHECK (2 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
   for (j = 0; j < 1024; j++)
-    CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
-                                                           &k1,
-                                                           "v2",
-                                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+    CHECK (GNUNET_OK ==
+           GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
+                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
   GNUNET_CONTAINER_multihashmap_destroy (m);
   return 0;
 }
diff --git a/src/util/test_container_slist.c b/src/util/test_container_slist.c
index 13c12bc5a..4a277dab5 100644
--- a/src/util/test_container_slist.c
+++ b/src/util/test_container_slist.c
@@ -46,8 +46,7 @@ main (int argc, char *argv[])
   GNUNET_assert (GNUNET_CONTAINER_slist_count (l) == 0);
 
   for (i = 0; i < 100; i++)
-    GNUNET_CONTAINER_slist_add (l,
-                                GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+    GNUNET_CONTAINER_slist_add (l, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
                                 &i, sizeof (i));
   GNUNET_assert (GNUNET_CONTAINER_slist_count (l) == 100);
 
@@ -105,8 +104,7 @@ main (int argc, char *argv[])
   GNUNET_assert (GNUNET_CONTAINER_slist_count (l) == 0);
 
   for (i = 0; i < 100; i++)
-    GNUNET_CONTAINER_slist_add (l,
-                                GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+    GNUNET_CONTAINER_slist_add (l, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
                                 &i, sizeof (i));
   /*check slist_append */
   GNUNET_CONTAINER_slist_append (l, l);
@@ -145,8 +143,7 @@ main (int argc, char *argv[])
   {
     ip = GNUNET_malloc (sizeof (int));
     *ip = i;
-    GNUNET_CONTAINER_slist_add (l,
-                                GNUNET_CONTAINER_SLIST_DISPOSITION_DYNAMIC,
+    GNUNET_CONTAINER_slist_add (l, GNUNET_CONTAINER_SLIST_DISPOSITION_DYNAMIC,
                                 ip, sizeof (int));
   }
   //creat_add
diff --git a/src/util/test_crypto_aes.c b/src/util/test_crypto_aes.c
index 968c7f40f..971e9afbe 100644
--- a/src/util/test_crypto_aes.c
+++ b/src/util/test_crypto_aes.c
@@ -39,22 +39,21 @@ testSymcipher ()
   char res[100];
 
   GNUNET_CRYPTO_aes_create_session_key (&key);
-  size = GNUNET_CRYPTO_aes_encrypt (TESTSTRING,
-                                    strlen (TESTSTRING) + 1,
-                                    &key,
-                                    (const struct
-                                     GNUNET_CRYPTO_AesInitializationVector *)
-                                    INITVALUE, result);
+  size =
+      GNUNET_CRYPTO_aes_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &key,
+                                 (const struct
+                                  GNUNET_CRYPTO_AesInitializationVector *)
+                                 INITVALUE, result);
   if (size == -1)
   {
     printf ("symciphertest failed: encryptBlock returned %d\n", size);
     return 1;
   }
-  size = GNUNET_CRYPTO_aes_decrypt (result, size,
-                                    &key,
-                                    (const struct
-                                     GNUNET_CRYPTO_AesInitializationVector *)
-                                    INITVALUE, res);
+  size =
+      GNUNET_CRYPTO_aes_decrypt (result, size, &key,
+                                 (const struct
+                                  GNUNET_CRYPTO_AesInitializationVector *)
+                                 INITVALUE, res);
   if (strlen (TESTSTRING) + 1 != size)
   {
     printf ("symciphertest failed: decryptBlock returned %d\n", size);
@@ -101,17 +100,15 @@ verifyCrypto ()
 
   if (ntohl (key.crc32) != (unsigned int) 38125195LL)
   {
-    printf ("Static key has different CRC: %u - %u\n",
-            ntohl (key.crc32), key.crc32);
+    printf ("Static key has different CRC: %u - %u\n", ntohl (key.crc32),
+            key.crc32);
 
     ret = 1;
     goto error;
   }
 
   if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
-      GNUNET_CRYPTO_aes_encrypt (plain,
-                                 GNUNET_CRYPTO_AES_KEY_LENGTH,
-                                 &key,
+      GNUNET_CRYPTO_aes_encrypt (plain, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
                                  (const struct
                                   GNUNET_CRYPTO_AesInitializationVector *)
                                  "testtesttesttest", result))
@@ -131,9 +128,7 @@ verifyCrypto ()
   res = GNUNET_malloc (GNUNET_CRYPTO_AES_KEY_LENGTH);
 
   if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
-      GNUNET_CRYPTO_aes_decrypt (result,
-                                 GNUNET_CRYPTO_AES_KEY_LENGTH,
-                                 &key,
+      GNUNET_CRYPTO_aes_decrypt (result, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
                                  (const struct
                                   GNUNET_CRYPTO_AesInitializationVector *)
                                  "testtesttesttest", res))
diff --git a/src/util/test_crypto_aes_weak.c b/src/util/test_crypto_aes_weak.c
index f54835b3d..a0161b575 100644
--- a/src/util/test_crypto_aes_weak.c
+++ b/src/util/test_crypto_aes_weak.c
@@ -94,9 +94,10 @@ testWeakKey ()
   weak_key.crc32 =
       htonl (GNUNET_CRYPTO_crc32_n (&weak_key, GNUNET_CRYPTO_AES_KEY_LENGTH));
 
-  size = GNUNET_CRYPTO_aes_encrypt (WEAK_KEY_TESTSTRING,
-                                    strlen (WEAK_KEY_TESTSTRING) + 1,
-                                    &weak_key, &INITVALUE, result);
+  size =
+      GNUNET_CRYPTO_aes_encrypt (WEAK_KEY_TESTSTRING,
+                                 strlen (WEAK_KEY_TESTSTRING) + 1, &weak_key,
+                                 &INITVALUE, result);
 
   if (size == -1)
   {
@@ -139,8 +140,8 @@ getWeakKeys ()
     /*printf("Got to run number %d.\n", number_of_runs); */
     GNUNET_CRYPTO_aes_create_session_key (&sessionkey);
 
-    rc = gcry_cipher_open (&handle,
-                           GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB, 0);
+    rc = gcry_cipher_open (&handle, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB,
+                           0);
 
     if (rc)
     {
@@ -188,8 +189,8 @@ main (int argc, char *argv[])
     }
     else
     {
-      printf ("\n%d weak keys found in %d runs.\n",
-              weak_keys, MAX_WEAK_KEY_TRIALS);
+      printf ("\n%d weak keys found in %d runs.\n", weak_keys,
+              MAX_WEAK_KEY_TRIALS);
     }
   }
 
diff --git a/src/util/test_crypto_hkdf.c b/src/util/test_crypto_hkdf.c
index a9b742922..752116194 100644
--- a/src/util/test_crypto_hkdf.c
+++ b/src/util/test_crypto_hkdf.c
@@ -43,8 +43,8 @@ tc1 ()
       { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
     0x0a, 0x0b, 0x0c
   };
-  unsigned char
-      info[10] = { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
+  unsigned char info[10] =
+      { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
   unsigned char okm[42] =
       { 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90, 0x43,
     0x4f, 0x64, 0xd0, 0x36, 0x2f, 0x2a, 0x2d, 0x2d, 0x0a, 0x90, 0xcf, 0x1a,
@@ -149,8 +149,8 @@ tc4 ()
       { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
     0x0a, 0x0b, 0x0c
   };
-  unsigned char
-      info[10] = { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
+  unsigned char info[10] =
+      { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
   unsigned char okm[42] =
       { 0x08, 0x5a, 0x01, 0xea, 0x1b, 0x10, 0xf3, 0x69, 0x33, 0x06,
     0x8b, 0x56, 0xef, 0xa5, 0xad, 0x81, 0xa4, 0xf1, 0x4b, 0x82, 0x2f, 0x5b,
diff --git a/src/util/test_crypto_ksk.c b/src/util/test_crypto_ksk.c
index 184f9f137..d4340f3ea 100644
--- a/src/util/test_crypto_ksk.c
+++ b/src/util/test_crypto_ksk.c
@@ -66,9 +66,8 @@ testCorrectKey ()
     snprintf (out, sizeof (out), "%02x", ((unsigned char *) &pkey)[i]);
     if (0 != strncmp (out, &want[i * 2], 2))
     {
-      fprintf (stderr,
-               " Failed! Wanted %.2s but got %2s at %d\n",
-               &want[i * 2], out, i);
+      fprintf (stderr, " Failed! Wanted %.2s but got %2s at %d\n", &want[i * 2],
+               out, i);
       return GNUNET_SYSERR;
     }
   }
@@ -144,17 +143,17 @@ testEncryptDecrypt (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
   for (i = 0; i < ITER; i++)
   {
     fprintf (stderr, ".");
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (TESTSTRING,
-                                                    strlen (TESTSTRING) + 1,
-                                                    &pkey, &target))
+    if (GNUNET_SYSERR ==
+        GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
+                                   &target))
     {
       fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
       ok++;
       continue;
     }
-    if (-1 == GNUNET_CRYPTO_rsa_decrypt (hostkey,
-                                         &target, result,
-                                         strlen (TESTSTRING) + 1))
+    if (-1 ==
+        GNUNET_CRYPTO_rsa_decrypt (hostkey, &target, result,
+                                   strlen (TESTSTRING) + 1))
     {
       fprintf (stderr, "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
       ok++;
@@ -162,16 +161,15 @@ testEncryptDecrypt (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
     }
     if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
     {
-      printf ("%s != %.*s - testEncryptDecrypt failed!\n",
-              TESTSTRING, MAX_TESTVAL, result);
+      printf ("%s != %.*s - testEncryptDecrypt failed!\n", TESTSTRING,
+              MAX_TESTVAL, result);
       ok++;
       continue;
     }
   }
-  printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
-          ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
+  printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n", ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value, ok);
   if (ok == 0)
     return GNUNET_OK;
   else
@@ -203,26 +201,25 @@ testSignVerify (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
       continue;
     }
     if (GNUNET_SYSERR ==
-        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
-                                  &purp, &sig, &pkey))
+        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
+                                  &pkey))
     {
       printf ("GNUNET_CRYPTO_rsa_verify failed!\n");
       ok = GNUNET_SYSERR;
       continue;
     }
     if (GNUNET_SYSERR !=
-        GNUNET_CRYPTO_rsa_verify
-        (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN, &purp, &sig, &pkey))
+        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
+                                  &purp, &sig, &pkey))
     {
       printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
       ok = GNUNET_SYSERR;
       continue;
     }
   }
-  printf ("%d RSA sign/verify operations %llums\n",
-          ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+  printf ("%d RSA sign/verify operations %llums\n", ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value);
   return ok;
 }
 
diff --git a/src/util/test_crypto_rsa.c b/src/util/test_crypto_rsa.c
index d7c23731e..bf058d285 100644
--- a/src/util/test_crypto_rsa.c
+++ b/src/util/test_crypto_rsa.c
@@ -56,17 +56,17 @@ testEncryptDecrypt ()
   for (i = 0; i < ITER; i++)
   {
     fprintf (stderr, ".");
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (TESTSTRING,
-                                                    strlen (TESTSTRING) + 1,
-                                                    &pkey, &target))
+    if (GNUNET_SYSERR ==
+        GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
+                                   &target))
     {
       fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
       ok++;
       continue;
     }
-    if (-1 == GNUNET_CRYPTO_rsa_decrypt (hostkey,
-                                         &target, result,
-                                         strlen (TESTSTRING) + 1))
+    if (-1 ==
+        GNUNET_CRYPTO_rsa_decrypt (hostkey, &target, result,
+                                   strlen (TESTSTRING) + 1))
     {
       fprintf (stderr, "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
       ok++;
@@ -75,16 +75,15 @@ testEncryptDecrypt ()
     }
     if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
     {
-      printf ("%s != %.*s - testEncryptDecrypt failed!\n",
-              TESTSTRING, (int) MAX_TESTVAL, result);
+      printf ("%s != %.*s - testEncryptDecrypt failed!\n", TESTSTRING,
+              (int) MAX_TESTVAL, result);
       ok++;
       continue;
     }
   }
-  printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
-          ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
+  printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n", ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value, ok);
   GNUNET_CRYPTO_rsa_key_free (hostkey);
   if (ok == 0)
     return GNUNET_OK;
@@ -112,19 +111,18 @@ testEncryptPerformance ()
   for (i = 0; i < ITER; i++)
   {
     fprintf (stderr, ".");
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (TESTSTRING,
-                                                    strlen (TESTSTRING) + 1,
-                                                    &pkey, &target))
+    if (GNUNET_SYSERR ==
+        GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
+                                   &target))
     {
       fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
       ok++;
       continue;
     }
   }
-  printf ("%d RSA encrypt operations %llu ms (%d failures)\n",
-          ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
+  printf ("%d RSA encrypt operations %llu ms (%d failures)\n", ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value, ok);
   GNUNET_CRYPTO_rsa_key_free (hostkey);
   if (ok != 0)
     return GNUNET_SYSERR;
@@ -154,19 +152,18 @@ testEncryptDecryptSK ()
   {
     fprintf (stderr, ".");
     GNUNET_CRYPTO_aes_create_session_key (&insk);
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (&insk,
-                                                    sizeof (struct
-                                                            GNUNET_CRYPTO_AesSessionKey),
-                                                    &pkey, &target))
+    if (GNUNET_SYSERR ==
+        GNUNET_CRYPTO_rsa_encrypt (&insk,
+                                   sizeof (struct GNUNET_CRYPTO_AesSessionKey),
+                                   &pkey, &target))
     {
       fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
       ok++;
       continue;
     }
-    if (-1 == GNUNET_CRYPTO_rsa_decrypt (hostkey,
-                                         &target, &outsk,
-                                         sizeof (struct
-                                                 GNUNET_CRYPTO_AesSessionKey)))
+    if (-1 ==
+        GNUNET_CRYPTO_rsa_decrypt (hostkey, &target, &outsk,
+                                   sizeof (struct GNUNET_CRYPTO_AesSessionKey)))
     {
       fprintf (stderr, "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
       ok++;
@@ -180,10 +177,9 @@ testEncryptDecryptSK ()
       continue;
     }
   }
-  printf ("%d RSA encrypt/decrypt SK operations %llums (%d failures)\n",
-          ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
+  printf ("%d RSA encrypt/decrypt SK operations %llums (%d failures)\n", ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value, ok);
   GNUNET_CRYPTO_rsa_key_free (hostkey);
   if (ok != 0)
     return GNUNET_SYSERR;
@@ -219,26 +215,25 @@ testSignVerify ()
       continue;
     }
     if (GNUNET_SYSERR ==
-        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
-                                  &purp, &sig, &pkey))
+        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
+                                  &pkey))
     {
       printf ("GNUNET_CRYPTO_rsa_verify failed!\n");
       ok = GNUNET_SYSERR;
       continue;
     }
     if (GNUNET_SYSERR !=
-        GNUNET_CRYPTO_rsa_verify
-        (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN, &purp, &sig, &pkey))
+        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
+                                  &purp, &sig, &pkey))
     {
       printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
       ok = GNUNET_SYSERR;
       continue;
     }
   }
-  printf ("%d RSA sign/verify operations %llums\n",
-          ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+  printf ("%d RSA sign/verify operations %llums\n", ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value);
   GNUNET_CRYPTO_rsa_key_free (hostkey);
   return ok;
 }
@@ -273,8 +268,8 @@ testSignPerformance ()
     }
   }
   printf ("%d RSA sign operations %llu ms\n", ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          rel_value);
   GNUNET_CRYPTO_rsa_key_free (hostkey);
   return ok;
 }
diff --git a/src/util/test_disk.c b/src/util/test_disk.c
index d8d8021e5..91154a6f5 100644
--- a/src/util/test_disk.c
+++ b/src/util/test_disk.c
@@ -37,8 +37,7 @@ testReadWrite ()
   int ret;
 
   if (strlen (TESTSTRING) !=
-      GNUNET_DISK_fn_write (".testfile", TESTSTRING,
-                            strlen (TESTSTRING),
+      GNUNET_DISK_fn_write (".testfile", TESTSTRING, strlen (TESTSTRING),
                             GNUNET_DISK_PERM_USER_READ |
                             GNUNET_DISK_PERM_USER_WRITE))
     return 1;
@@ -53,9 +52,8 @@ testReadWrite ()
   tmp[ret] = '\0';
   if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
   {
-    fprintf (stderr,
-             "Error in testReadWrite: *%s* != *%s* for file %s\n",
-             tmp, TESTSTRING, ".testfile");
+    fprintf (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
+             TESTSTRING, ".testfile");
     return 1;
   }
   GNUNET_DISK_file_copy (".testfile", ".testfile2");
@@ -63,16 +61,15 @@ testReadWrite ()
   ret = GNUNET_DISK_fn_read (".testfile2", tmp, sizeof (tmp) - 1);
   if (ret < 0)
   {
-    fprintf (stderr,
-             "Error reading file `%s' in testReadWrite\n", ".testfile2");
+    fprintf (stderr, "Error reading file `%s' in testReadWrite\n",
+             ".testfile2");
     return 1;
   }
   tmp[ret] = '\0';
   if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
   {
-    fprintf (stderr,
-             "Error in testReadWrite: *%s* != *%s* for file %s\n",
-             tmp, TESTSTRING, ".testfile2");
+    fprintf (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
+             TESTSTRING, ".testfile2");
     return 1;
   }
 
@@ -91,8 +88,9 @@ testOpenClose ()
   uint64_t size;
   long avail;
 
-  fh = GNUNET_DISK_file_open (".testfile", GNUNET_DISK_OPEN_READWRITE
-                              | GNUNET_DISK_OPEN_CREATE,
+  fh = GNUNET_DISK_file_open (".testfile",
+                              GNUNET_DISK_OPEN_READWRITE |
+                              GNUNET_DISK_OPEN_CREATE,
                               GNUNET_DISK_PERM_USER_READ |
                               GNUNET_DISK_PERM_USER_WRITE);
   GNUNET_assert (GNUNET_NO == GNUNET_DISK_handle_invalid (fh));
@@ -108,8 +106,9 @@ testOpenClose ()
   GNUNET_log_skip (1, GNUNET_NO);
   avail = GNUNET_DISK_get_blocks_available (".testfile");
   GNUNET_log_skip (0, GNUNET_NO);
-  fh = GNUNET_DISK_file_open (".testfile", GNUNET_DISK_OPEN_READWRITE
-                              | GNUNET_DISK_OPEN_CREATE,
+  fh = GNUNET_DISK_file_open (".testfile",
+                              GNUNET_DISK_OPEN_READWRITE |
+                              GNUNET_DISK_OPEN_CREATE,
                               GNUNET_DISK_PERM_USER_WRITE |
                               GNUNET_DISK_PERM_USER_READ);
   GNUNET_assert (GNUNET_NO == GNUNET_DISK_handle_invalid (fh));
@@ -156,8 +155,7 @@ testDirScan ()
 }
 
 static void
-iter_callback (void *cls,
-               struct GNUNET_DISK_DirectoryIterator *di,
+iter_callback (void *cls, struct GNUNET_DISK_DirectoryIterator *di,
                const char *filename, const char *dirname)
 {
   int *i = cls;
diff --git a/src/util/test_os_network.c b/src/util/test_os_network.c
index e92eba2c9..583a5fb82 100644
--- a/src/util/test_os_network.c
+++ b/src/util/test_os_network.c
@@ -34,9 +34,8 @@
  * (success).
  */
 static int
-proc (void *cls,
-      const char *name,
-      int isDefault, const struct sockaddr *addr, socklen_t addrlen)
+proc (void *cls, const char *name, int isDefault, const struct sockaddr *addr,
+      socklen_t addrlen)
 {
   int *ok = cls;
   char buf[INET6_ADDRSTRLEN];
@@ -45,9 +44,9 @@ proc (void *cls,
     return GNUNET_OK;
 
   inet_ntop (addr->sa_family,
-             (addr->sa_family == AF_INET) ?
-             (void *) &((struct sockaddr_in *) addr)->sin_addr :
-             (void *) &((struct sockaddr_in6 *) addr)->sin6_addr,
+             (addr->sa_family ==
+              AF_INET) ? (void *) &((struct sockaddr_in *) addr)->
+             sin_addr : (void *) &((struct sockaddr_in6 *) addr)->sin6_addr,
              buf, sizeof (buf));
   if ((0 == strcmp ("::1", buf)) || (0 == strcmp ("127.0.0.1", buf)))
     *ok = 0;
diff --git a/src/util/test_os_start_process.c b/src/util/test_os_start_process.c
index 4137118fa..36dd42a23 100644
--- a/src/util/test_os_start_process.c
+++ b/src/util/test_os_start_process.c
@@ -125,8 +125,9 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;
   }
 
-  proc = GNUNET_OS_start_process (hello_pipe_stdin, hello_pipe_stdout, fn,
-                                  "test_gnunet_echo_hello", "-", NULL);
+  proc =
+      GNUNET_OS_start_process (hello_pipe_stdin, hello_pipe_stdout, fn,
+                               "test_gnunet_echo_hello", "-", NULL);
   GNUNET_free (fn);
 
   /* Close the write end of the read pipe */
diff --git a/src/util/test_program.c b/src/util/test_program.c
index 9ea5b1510..faeb4e716 100644
--- a/src/util/test_program.c
+++ b/src/util/test_program.c
@@ -57,9 +57,8 @@ static struct GNUNET_GETOPT_CommandLineOption options4[] = {
  */
 
 static void
-runner (void *cls,
-        char *const *args,
-        const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
+runner (void *cls, char *const *args, const char *cfgfile,
+        const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int *ok = cls;
 
@@ -92,26 +91,18 @@ check ()
   };
 
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7,
-                                     argv,
-                                     "test_program",
-                                     "A test", options1, &runner, &ok));
+                 GNUNET_PROGRAM_run (7, argv, "test_program", "A test",
+                                     options1, &runner, &ok));
 
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7,
-                                     argv,
-                                     "test_program",
-                                     "A test", options2, &runner, &ok));
+                 GNUNET_PROGRAM_run (7, argv, "test_program", "A test",
+                                     options2, &runner, &ok));
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7,
-                                     argv,
-                                     "test_program",
-                                     "A test", options3, &runner, &ok));
+                 GNUNET_PROGRAM_run (7, argv, "test_program", "A test",
+                                     options3, &runner, &ok));
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7,
-                                     argv,
-                                     "test_program",
-                                     "A test", options4, &runner, &ok));
+                 GNUNET_PROGRAM_run (7, argv, "test_program", "A test",
+                                     options4, &runner, &ok));
 
   return ok;
 }
diff --git a/src/util/test_pseudonym.c b/src/util/test_pseudonym.c
index dfdcbb1bb..20a3d3d96 100644
--- a/src/util/test_pseudonym.c
+++ b/src/util/test_pseudonym.c
@@ -38,15 +38,12 @@ static struct GNUNET_CONTAINER_MetaData *meta;
 static GNUNET_HashCode id1;
 
 static int
-iter (void *cls,
-      const GNUNET_HashCode *
-      pseudonym, const struct GNUNET_CONTAINER_MetaData *md, int rating)
+iter (void *cls, const GNUNET_HashCode * pseudonym,
+      const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
   int *ok = cls;
 
-  if ((0 == memcmp (pseudonym,
-                    &id1,
-                    sizeof (GNUNET_HashCode))) &&
+  if ((0 == memcmp (pseudonym, &id1, sizeof (GNUNET_HashCode))) &&
       (!GNUNET_CONTAINER_meta_data_test_equal (md, meta)))
   {
     *ok = GNUNET_NO;
@@ -56,9 +53,7 @@ iter (void *cls,
 }
 
 static int
-noti_callback (void *cls,
-               const GNUNET_HashCode *
-               pseudonym,
+noti_callback (void *cls, const GNUNET_HashCode * pseudonym,
                const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
   int *ret = cls;
@@ -68,9 +63,7 @@ noti_callback (void *cls,
 }
 
 static int
-fake_noti_callback (void *cls,
-                    const GNUNET_HashCode *
-                    pseudonym,
+fake_noti_callback (void *cls, const GNUNET_HashCode * pseudonym,
                     const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
   int *ret = cls;
@@ -80,8 +73,7 @@ fake_noti_callback (void *cls,
 }
 
 static int
-false_callback (void *cls,
-                const GNUNET_HashCode * pseudonym,
+false_callback (void *cls, const GNUNET_HashCode * pseudonym,
                 const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
   return GNUNET_OK;
@@ -125,8 +117,7 @@ main (int argc, char *argv[])
   notiCount = 0;
   fakenotiCount = 0;
   count = 0;
-  GNUNET_PSEUDONYM_discovery_callback_register (cfg,
-                                                &fake_noti_callback,
+  GNUNET_PSEUDONYM_discovery_callback_register (cfg, &fake_noti_callback,
                                                 &fakenotiCount);
   GNUNET_PSEUDONYM_discovery_callback_register (cfg, &noti_callback,
                                                 &notiCount);
@@ -137,11 +128,9 @@ main (int argc, char *argv[])
   /* ACTUAL TEST CODE */
   old = GNUNET_PSEUDONYM_list_all (cfg, NULL, NULL);
   meta = GNUNET_CONTAINER_meta_data_create ();
-  GNUNET_CONTAINER_meta_data_insert (meta,
-                                     "<test>",
-                                     EXTRACTOR_METATYPE_TITLE,
-                                     EXTRACTOR_METAFORMAT_UTF8,
-                                     "text/plain", "test", strlen ("test") + 1);
+  GNUNET_CONTAINER_meta_data_insert (meta, "<test>", EXTRACTOR_METATYPE_TITLE,
+                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                     "test", strlen ("test") + 1);
   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &id1);
   GNUNET_PSEUDONYM_add (cfg, &id1, meta);
   CHECK (notiCount == 1);
@@ -155,14 +144,12 @@ main (int argc, char *argv[])
   CHECK (notiCount == 3);
   newVal = GNUNET_PSEUDONYM_list_all (cfg, &iter, &ok);
   CHECK (old < newVal);
-  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (meta,
-                                                                 "<test>",
-                                                                 EXTRACTOR_METATYPE_COMMENT,
-                                                                 EXTRACTOR_METAFORMAT_UTF8,
-                                                                 "text/plain",
-                                                                 m,
-                                                                 strlen (m) +
-                                                                 1));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
+                                                    EXTRACTOR_METATYPE_COMMENT,
+                                                    EXTRACTOR_METAFORMAT_UTF8,
+                                                    "text/plain", m,
+                                                    strlen (m) + 1));
   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &id3);
   GNUNET_PSEUDONYM_add (cfg, &id3, meta);
   name3 = GNUNET_PSEUDONYM_id_to_name (cfg, &id3);
diff --git a/src/util/test_resolver_api.c b/src/util/test_resolver_api.c
index 8058fa287..563f204eb 100644
--- a/src/util/test_resolver_api.c
+++ b/src/util/test_resolver_api.c
@@ -65,16 +65,16 @@ check_localhost_num (void *cls, const char *hostname)
   if (0 == strcmp (hostname, "127.0.0.1"))
   {
 #if DEBUG_RESOLVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received correct hostname `%s'.\n", hostname);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct hostname `%s'.\n",
+                hostname);
 #endif
     (*ok) &= ~4;
   }
   else
   {
 #if DEBUG_RESOLVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received invalid hostname `%s'.\n", hostname);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received invalid hostname `%s'.\n",
+                hostname);
 #endif
     GNUNET_break (0);
   }
@@ -91,8 +91,8 @@ check_localhost (void *cls, const char *hostname)
   if (0 == strcmp (hostname, "localhost"))
   {
 #if DEBUG_RESOLVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received correct hostname `%s'.\n", hostname);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct hostname `%s'.\n",
+                hostname);
 #endif
     (*ok) &= ~2;
   }
@@ -139,20 +139,20 @@ check_local_fqdn (void *cls, const char *gnunet_fqdn)
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
-                         GNUNET_ERROR_TYPE_BULK, "gethostname");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "gethostname");
     return;
   }
 #if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Resolving our FQDN `%s'\n"), hostname);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolving our FQDN `%s'\n"),
+              hostname);
 #endif
   host = gethostbyname (hostname);
   if (NULL == host)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Could not resolve our FQDN : %s %u\n"),
-                hstrerror (h_errno), h_errno);
+                _("Could not resolve our FQDN : %s %u\n"), hstrerror (h_errno),
+                h_errno);
     return;
   }
 
@@ -224,8 +224,8 @@ check_rootserver_name (void *cls, const char *hostname)
 }
 
 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)
 {
   int *ok = cls;
   struct sockaddr_in sa;
@@ -283,8 +283,9 @@ run (void *cls, char *const *args,
   }
 
   /* Comparing to resolved address to the address the root name server should have */
-  if (strcmp (inet_ntoa (*(struct in_addr *) rootserver->h_addr_list[0]),
-              ROOTSERVER_IP) != 0)
+  if (strcmp
+      (inet_ntoa (*(struct in_addr *) rootserver->h_addr_list[0]),
+       ROOTSERVER_IP) != 0)
   {
 #if DEBUG_RESOLVER
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -318,8 +319,8 @@ run (void *cls, char *const *args,
     GNUNET_break (0);
   }
 
-  rootserver
-      = gethostbyaddr (&rootserver_addr, sizeof (rootserver_addr), AF_INET);
+  rootserver =
+      gethostbyaddr (&rootserver_addr, sizeof (rootserver_addr), AF_INET);
   if (rootserver == NULL)
   {
     /* Error: resolving IP addresses does not work */
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c
index d5a701692..3d8ae979c 100644
--- a/src/util/test_scheduler.c
+++ b/src/util/test_scheduler.c
@@ -50,8 +50,8 @@ task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (2 == *ok);
   (*ok) = 3;
   /* t3 will go before t4: higher priority */
-  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
-                                      &task3, cls);
+  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI, &task3,
+                                      cls);
 }
 
 static void
@@ -106,8 +106,8 @@ taskRd (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, fds[0]));
   GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1));
   (*ok) = 8;
-  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                      &taskLast, cls);
+  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, &taskLast,
+                                      cls);
   GNUNET_SCHEDULER_shutdown ();
 }
 
@@ -123,10 +123,10 @@ task5 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (NULL != p);
   fds[0] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_READ);
   fds[1] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_WRITE);
-  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  fds[0], &taskRd, cls);
-  GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                   fds[1], &taskWrt, cls);
+  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, fds[0], &taskRd,
+                                  cls);
+  GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, fds[1],
+                                   &taskWrt, cls);
 }
 
 
@@ -225,8 +225,8 @@ taskCancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   GNUNET_assert (1 == *ok);
   *ok = 0;
-  GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
-                                                       &taskNeverRun, NULL));
+  GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_add_after
+                           (GNUNET_SCHEDULER_NO_TASK, &taskNeverRun, NULL));
 }
 
 
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c
index b98e76eeb..8bcfa096e 100644
--- a/src/util/test_scheduler_delay.c
+++ b/src/util/test_scheduler_delay.c
@@ -66,8 +66,8 @@ test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;
   }
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                (GNUNET_TIME_UNIT_MILLISECONDS, i),
-                                &test_task, NULL);
+                                (GNUNET_TIME_UNIT_MILLISECONDS, i), &test_task,
+                                NULL);
   i += INCR;
 }
 
@@ -76,8 +76,8 @@ check ()
 {
   target = GNUNET_TIME_absolute_get ();
   GNUNET_SCHEDULER_run (&test_task, NULL);
-  FPRINTF (stdout,
-           "Sleep precision: %llu ms. ", cumDelta / 1000 / (MAXV / INCR));
+  FPRINTF (stdout, "Sleep precision: %llu ms. ",
+           cumDelta / 1000 / (MAXV / INCR));
   if (cumDelta <= 10 * MAXV / INCR)
     fprintf (stdout, "Timer precision is excellent.\n");
   else if (cumDelta <= 50 * MAXV / INCR)        /* 50 ms average deviation */
diff --git a/src/util/test_server.c b/src/util/test_server.c
index 577a841ff..59bf8a2f4 100644
--- a/src/util/test_server.c
+++ b/src/util/test_server.c
@@ -60,8 +60,7 @@ finish_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-recv_fin_cb (void *cls,
-             struct GNUNET_SERVER_Client *client,
+recv_fin_cb (void *cls, struct GNUNET_SERVER_Client *client,
              const struct GNUNET_MessageHeader *message)
 {
   GNUNET_assert (ok == 5);
@@ -98,8 +97,7 @@ reply_msg (void *cls, size_t size, void *buf)
 
 
 static void
-recv_cb (void *cls,
-         struct GNUNET_SERVER_Client *client,
+recv_cb (void *cls, struct GNUNET_SERVER_Client *client,
          const struct GNUNET_MessageHeader *message)
 {
   GNUNET_assert (ok == 2);
@@ -111,8 +109,8 @@ recv_cb (void *cls,
   GNUNET_assert (NULL !=
                  GNUNET_SERVER_notify_transmit_ready (client,
                                                       ntohs (message->size),
-                                                      TIMEOUT,
-                                                      &reply_msg, NULL));
+                                                      TIMEOUT, &reply_msg,
+                                                      NULL));
 }
 
 
diff --git a/src/util/test_server_disconnect.c b/src/util/test_server_disconnect.c
index 03d57a222..8010695e8 100644
--- a/src/util/test_server_disconnect.c
+++ b/src/util/test_server_disconnect.c
@@ -80,8 +80,7 @@ server_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-recv_cb (void *cls,
-         struct GNUNET_SERVER_Client *client,
+recv_cb (void *cls, struct GNUNET_SERVER_Client *client,
          const struct GNUNET_MessageHeader *message)
 {
   GNUNET_assert (ok == 2);
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c
index 4b9d84059..06a4b71d6 100644
--- a/src/util/test_server_with_client.c
+++ b/src/util/test_server_with_client.c
@@ -57,8 +57,7 @@ send_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-recv_cb (void *cls,
-         struct GNUNET_SERVER_Client *argclient,
+recv_cb (void *cls, struct GNUNET_SERVER_Client *argclient,
          const struct GNUNET_MessageHeader *message)
 {
   void *addr;
@@ -169,13 +168,10 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #endif
   sa.sin_family = AF_INET;
   sa.sin_port = htons (PORT);
-  server = GNUNET_SERVER_create (NULL,
-                                 NULL,
-                                 sap,
-                                 slens,
-                                 GNUNET_TIME_relative_multiply
-                                 (GNUNET_TIME_UNIT_MILLISECONDS, 250),
-                                 GNUNET_NO);
+  server =
+      GNUNET_SERVER_create (NULL, NULL, sap, slens,
+                            GNUNET_TIME_relative_multiply
+                            (GNUNET_TIME_UNIT_MILLISECONDS, 250), GNUNET_NO);
   GNUNET_assert (server != NULL);
   handlers[0].callback_cls = cls;
   GNUNET_SERVER_add_handlers (server, handlers);
@@ -187,8 +183,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                          "localhost");
   client = GNUNET_CLIENT_connect ("test", cfg);
   GNUNET_assert (client != NULL);
-  GNUNET_CLIENT_notify_transmit_ready (client,
-                                       256,
+  GNUNET_CLIENT_notify_transmit_ready (client, 256,
                                        GNUNET_TIME_relative_multiply
                                        (GNUNET_TIME_UNIT_MILLISECONDS, 250),
                                        GNUNET_NO, &notify_ready, NULL);
diff --git a/src/util/test_server_with_client_unix.c b/src/util/test_server_with_client_unix.c
index 00df21129..99af4e8c3 100644
--- a/src/util/test_server_with_client_unix.c
+++ b/src/util/test_server_with_client_unix.c
@@ -55,8 +55,7 @@ send_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-recv_cb (void *cls,
-         struct GNUNET_SERVER_Client *argclient,
+recv_cb (void *cls, struct GNUNET_SERVER_Client *argclient,
          const struct GNUNET_MessageHeader *message)
 {
   switch (ok)
@@ -156,13 +155,10 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   slens[0] = sizeof (un);
   sap[1] = NULL;
   slens[1] = 0;
-  server = GNUNET_SERVER_create (NULL,
-                                 NULL,
-                                 sap,
-                                 slens,
-                                 GNUNET_TIME_relative_multiply
-                                 (GNUNET_TIME_UNIT_MILLISECONDS, 250),
-                                 GNUNET_NO);
+  server =
+      GNUNET_SERVER_create (NULL, NULL, sap, slens,
+                            GNUNET_TIME_relative_multiply
+                            (GNUNET_TIME_UNIT_MILLISECONDS, 250), GNUNET_NO);
   GNUNET_assert (server != NULL);
   handlers[0].callback_cls = cls;
   GNUNET_SERVER_add_handlers (server, handlers);
@@ -175,8 +171,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   client = GNUNET_CLIENT_connect ("test", cfg);
   GNUNET_assert (client != NULL);
-  GNUNET_CLIENT_notify_transmit_ready (client,
-                                       256,
+  GNUNET_CLIENT_notify_transmit_ready (client, 256,
                                        GNUNET_TIME_relative_multiply
                                        (GNUNET_TIME_UNIT_MILLISECONDS, 250),
                                        GNUNET_NO, &notify_ready, NULL);
diff --git a/src/util/test_service.c b/src/util/test_service.c
index daafa6cd3..4d1608191 100644
--- a/src/util/test_service.c
+++ b/src/util/test_service.c
@@ -71,8 +71,8 @@ ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
               "Client connecting, waiting to transmit\n");
   GNUNET_CLIENT_notify_transmit_ready (client,
                                        sizeof (struct GNUNET_MessageHeader),
-                                       GNUNET_TIME_UNIT_SECONDS,
-                                       GNUNET_NO, &build_msg, client);
+                                       GNUNET_TIME_UNIT_SECONDS, GNUNET_NO,
+                                       &build_msg, client);
 }
 
 static void
@@ -83,8 +83,7 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-recv_cb (void *cls,
-         struct GNUNET_SERVER_Client *client,
+recv_cb (void *cls, struct GNUNET_SERVER_Client *client,
          const struct GNUNET_MessageHeader *message)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");
@@ -105,15 +104,13 @@ static struct GNUNET_SERVER_MessageHandler myhandlers[] = {
 
 
 static void
-runner (void *cls,
-        struct GNUNET_SERVER_Handle *server,
+runner (void *cls, struct GNUNET_SERVER_Handle *server,
         const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service initializing\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);
-  GNUNET_CLIENT_service_test ("test_service",
-                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready,
-                              (void *) cfg);
+  GNUNET_CLIENT_service_test ("test_service", cfg, GNUNET_TIME_UNIT_SECONDS,
+                              &ready, (void *) cfg);
 }
 
 
@@ -139,9 +136,7 @@ check ()
   };
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting service\n");
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_SERVICE_run (5,
-                                     argv,
-                                     "test_service",
+                 GNUNET_SERVICE_run (5, argv, "test_service",
                                      GNUNET_SERVICE_OPTION_NONE, &runner, &ok));
   GNUNET_assert (0 == ok);
   return ok;
@@ -160,20 +155,18 @@ ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
   GNUNET_CLIENT_notify_transmit_ready (client,
                                        sizeof (struct GNUNET_MessageHeader),
-                                       GNUNET_TIME_UNIT_SECONDS,
-                                       GNUNET_NO, &build_msg, client);
+                                       GNUNET_TIME_UNIT_SECONDS, GNUNET_NO,
+                                       &build_msg, client);
 }
 
 static void
-runner6 (void *cls,
-         struct GNUNET_SERVER_Handle *server,
+runner6 (void *cls, struct GNUNET_SERVER_Handle *server,
          const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);
-  GNUNET_CLIENT_service_test ("test_service6",
-                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready6,
-                              (void *) cfg);
+  GNUNET_CLIENT_service_test ("test_service6", cfg, GNUNET_TIME_UNIT_SECONDS,
+                              &ready6, (void *) cfg);
 }
 
 /**
@@ -197,11 +190,9 @@ check6 ()
   };
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting v6 service\n");
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_SERVICE_run (5,
-                                     argv,
-                                     "test_service6",
-                                     GNUNET_SERVICE_OPTION_NONE,
-                                     &runner6, &ok));
+                 GNUNET_SERVICE_run (5, argv, "test_service6",
+                                     GNUNET_SERVICE_OPTION_NONE, &runner6,
+                                     &ok));
   GNUNET_assert (0 == ok);
   return ok;
 }
@@ -209,9 +200,7 @@ check6 ()
 
 
 static void
-start_stop_main (void *cls,
-                 char *const *args,
-                 const char *cfgfile,
+start_stop_main (void *cls, char *const *args, const char *cfgfile,
                  const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int *ret = cls;
@@ -245,10 +234,7 @@ check_start_stop ()
   int ret = 1;
 
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (5,
-                                     argv,
-                                     "test-service-program",
-                                     "no help",
+                 GNUNET_PROGRAM_run (5, argv, "test-service-program", "no help",
                                      options, &start_stop_main, &ret));
 
   GNUNET_break (0 == ret);
@@ -278,8 +264,8 @@ main (int argc, char *argv[])
 #endif
   if (NULL == s)
   {
-    if ((errno == ENOBUFS) ||
-        (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
+    if ((errno == ENOBUFS) || (errno == ENOMEM) || (errno == ENFILE) ||
+        (errno == EACCES))
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
       return 1;
diff --git a/src/util/test_time.c b/src/util/test_time.c
index 788884fcc..6a05b698c 100644
--- a/src/util/test_time.c
+++ b/src/util/test_time.c
@@ -108,8 +108,8 @@ check ()
   GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).rel_value ==
                  0);
 
-  GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).rel_value
-                 == forever.abs_value);
+  GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).
+                 rel_value == forever.abs_value);
 
   past.abs_value = now.abs_value - 1000000;
   rel = GNUNET_TIME_absolute_get_duration (future);
@@ -153,7 +153,8 @@ check ()
 
   GNUNET_assert (forever.abs_value ==
                  GNUNET_TIME_absolute_subtract (forever,
-                                                GNUNET_TIME_UNIT_MINUTES).abs_value);
+                                                GNUNET_TIME_UNIT_MINUTES).
+                 abs_value);
   /*check absolute subtract */
   now.abs_value = 50000;
   rel.rel_value = 100000;
diff --git a/src/util/time.c b/src/util/time.c
index f4d4c4070..34880b08b 100644
--- a/src/util/time.c
+++ b/src/util/time.c
@@ -145,9 +145,8 @@ GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
  * @return timestamp that is smaller
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_min (struct
-                          GNUNET_TIME_Relative
-                          t1, struct GNUNET_TIME_Relative t2)
+GNUNET_TIME_relative_min (struct GNUNET_TIME_Relative t1,
+                          struct GNUNET_TIME_Relative t2)
 {
   return (t1.rel_value < t2.rel_value) ? t1 : t2;
 }
@@ -161,9 +160,8 @@ GNUNET_TIME_relative_min (struct
  * @return timestamp that is larger
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_max (struct
-                          GNUNET_TIME_Relative
-                          t1, struct GNUNET_TIME_Relative t2)
+GNUNET_TIME_relative_max (struct GNUNET_TIME_Relative t1,
+                          struct GNUNET_TIME_Relative t2)
 {
   return (t1.rel_value > t2.rel_value) ? t1 : t2;
 }
@@ -178,9 +176,8 @@ GNUNET_TIME_relative_max (struct
  * @return timestamp that is smaller
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_min (struct
-                          GNUNET_TIME_Absolute
-                          t1, struct GNUNET_TIME_Absolute t2)
+GNUNET_TIME_absolute_min (struct GNUNET_TIME_Absolute t1,
+                          struct GNUNET_TIME_Absolute t2)
 {
   return (t1.abs_value < t2.abs_value) ? t1 : t2;
 }
@@ -194,9 +191,8 @@ GNUNET_TIME_absolute_min (struct
  * @return timestamp that is smaller
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_max (struct
-                          GNUNET_TIME_Absolute
-                          t1, struct GNUNET_TIME_Absolute t2)
+GNUNET_TIME_absolute_max (struct GNUNET_TIME_Absolute t1,
+                          struct GNUNET_TIME_Absolute t2)
 {
   return (t1.abs_value > t2.abs_value) ? t1 : t2;
 }
@@ -298,9 +294,8 @@ GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
  * @return ZERO if start <= duration, or FOREVER if start time is FOREVER; start-duration otherwise
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_subtract (struct
-                               GNUNET_TIME_Absolute
-                               start, struct GNUNET_TIME_Relative duration)
+GNUNET_TIME_absolute_subtract (struct GNUNET_TIME_Absolute start,
+                               struct GNUNET_TIME_Relative duration)
 {
   struct GNUNET_TIME_Absolute ret;
 
@@ -368,8 +363,8 @@ GNUNET_TIME_relative_divide (struct GNUNET_TIME_Relative rel,
  *        assuming it continues at the same speed
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start,
-                           uint64_t finished, uint64_t total)
+GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start, uint64_t finished,
+                           uint64_t total)
 {
   struct GNUNET_TIME_Relative dur;
   double exp;
diff --git a/src/util/winproc.c b/src/util/winproc.c
index 4fa3ab484..9594c5d6f 100644
--- a/src/util/winproc.c
+++ b/src/util/winproc.c
@@ -100,8 +100,9 @@ GNInitWinEnv ()
   /* Function to get CPU usage under Win NT */
   if (hNTDLL)
   {
-    GNNtQuerySystemInformation = (TNtQuerySystemInformation)
-        GetProcAddress (hNTDLL, "NtQuerySystemInformation");
+    GNNtQuerySystemInformation =
+        (TNtQuerySystemInformation) GetProcAddress (hNTDLL,
+                                                    "NtQuerySystemInformation");
   }
   else
   {
@@ -113,13 +114,13 @@ GNInitWinEnv ()
   if (hIphlpapi)
   {
     GNGetIfEntry = (TGetIfEntry) GetProcAddress (hIphlpapi, "GetIfEntry");
-    GNGetIpAddrTable = (TGetIpAddrTable) GetProcAddress (hIphlpapi,
-                                                         "GetIpAddrTable");
+    GNGetIpAddrTable =
+        (TGetIpAddrTable) GetProcAddress (hIphlpapi, "GetIpAddrTable");
     GNGetIfTable = (TGetIfTable) GetProcAddress (hIphlpapi, "GetIfTable");
-    GNGetBestInterface = (TGetBestInterface) GetProcAddress (hIphlpapi,
-                                                             "GetBestInterface");
-    GGetAdaptersInfo = (TGetAdaptersInfo) GetProcAddress (hIphlpapi,
-                                                          "GetAdaptersInfo");
+    GNGetBestInterface =
+        (TGetBestInterface) GetProcAddress (hIphlpapi, "GetBestInterface");
+    GGetAdaptersInfo =
+        (TGetAdaptersInfo) GetProcAddress (hIphlpapi, "GetAdaptersInfo");
   }
   else
   {
@@ -134,51 +135,57 @@ GNInitWinEnv ()
   hAdvapi = LoadLibrary ("advapi32.dll");
   if (hAdvapi)
   {
-    GNOpenSCManager = (TOpenSCManager)
-        GetProcAddress (hAdvapi, "OpenSCManagerA");
-    GNCreateService = (TCreateService)
-        GetProcAddress (hAdvapi, "CreateServiceA");
-    GNCloseServiceHandle = (TCloseServiceHandle)
-        GetProcAddress (hAdvapi, "CloseServiceHandle");
-    GNDeleteService = (TDeleteService)
-        GetProcAddress (hAdvapi, "DeleteService");
-    GNRegisterServiceCtrlHandler = (TRegisterServiceCtrlHandler)
-        GetProcAddress (hAdvapi, "RegisterServiceCtrlHandlerA");
-    GNSetServiceStatus = (TSetServiceStatus)
-        GetProcAddress (hAdvapi, "SetServiceStatus");
-    GNStartServiceCtrlDispatcher = (TStartServiceCtrlDispatcher)
-        GetProcAddress (hAdvapi, "StartServiceCtrlDispatcherA");
-    GNControlService = (TControlService)
-        GetProcAddress (hAdvapi, "ControlService");
+    GNOpenSCManager =
+        (TOpenSCManager) GetProcAddress (hAdvapi, "OpenSCManagerA");
+    GNCreateService =
+        (TCreateService) GetProcAddress (hAdvapi, "CreateServiceA");
+    GNCloseServiceHandle =
+        (TCloseServiceHandle) GetProcAddress (hAdvapi, "CloseServiceHandle");
+    GNDeleteService =
+        (TDeleteService) GetProcAddress (hAdvapi, "DeleteService");
+    GNRegisterServiceCtrlHandler =
+        (TRegisterServiceCtrlHandler) GetProcAddress (hAdvapi,
+                                                      "RegisterServiceCtrlHandlerA");
+    GNSetServiceStatus =
+        (TSetServiceStatus) GetProcAddress (hAdvapi, "SetServiceStatus");
+    GNStartServiceCtrlDispatcher =
+        (TStartServiceCtrlDispatcher) GetProcAddress (hAdvapi,
+                                                      "StartServiceCtrlDispatcherA");
+    GNControlService =
+        (TControlService) GetProcAddress (hAdvapi, "ControlService");
     GNOpenService = (TOpenService) GetProcAddress (hAdvapi, "OpenServiceA");
 
-    GNLsaOpenPolicy = (TLsaOpenPolicy)
-        GetProcAddress (hAdvapi, "LsaOpenPolicy");
-    GNLsaAddAccountRights = (TLsaAddAccountRights)
-        GetProcAddress (hAdvapi, "LsaAddAccountRights");
-    GNLsaRemoveAccountRights = (TLsaRemoveAccountRights)
-        GetProcAddress (hAdvapi, "LsaRemoveAccountRights");
+    GNLsaOpenPolicy =
+        (TLsaOpenPolicy) GetProcAddress (hAdvapi, "LsaOpenPolicy");
+    GNLsaAddAccountRights =
+        (TLsaAddAccountRights) GetProcAddress (hAdvapi, "LsaAddAccountRights");
+    GNLsaRemoveAccountRights =
+        (TLsaRemoveAccountRights) GetProcAddress (hAdvapi,
+                                                  "LsaRemoveAccountRights");
     GNLsaClose = (TLsaClose) GetProcAddress (hAdvapi, "LsaClose");
-    GNLookupAccountName = (TLookupAccountName)
-        GetProcAddress (hAdvapi, "LookupAccountNameA");
-
-    GNGetFileSecurity = (TGetFileSecurity)
-        GetProcAddress (hAdvapi, "GetFileSecurityA");
-    GNInitializeSecurityDescriptor = (TInitializeSecurityDescriptor)
-        GetProcAddress (hAdvapi, "InitializeSecurityDescriptor");
-    GNGetSecurityDescriptorDacl = (TGetSecurityDescriptorDacl)
-        GetProcAddress (hAdvapi, "GetSecurityDescriptorDacl");
-    GNGetAclInformation = (TGetAclInformation)
-        GetProcAddress (hAdvapi, "GetAclInformation");
-    GNInitializeAcl = (TInitializeAcl)
-        GetProcAddress (hAdvapi, "InitializeAcl");
+    GNLookupAccountName =
+        (TLookupAccountName) GetProcAddress (hAdvapi, "LookupAccountNameA");
+
+    GNGetFileSecurity =
+        (TGetFileSecurity) GetProcAddress (hAdvapi, "GetFileSecurityA");
+    GNInitializeSecurityDescriptor =
+        (TInitializeSecurityDescriptor) GetProcAddress (hAdvapi,
+                                                        "InitializeSecurityDescriptor");
+    GNGetSecurityDescriptorDacl =
+        (TGetSecurityDescriptorDacl) GetProcAddress (hAdvapi,
+                                                     "GetSecurityDescriptorDacl");
+    GNGetAclInformation =
+        (TGetAclInformation) GetProcAddress (hAdvapi, "GetAclInformation");
+    GNInitializeAcl =
+        (TInitializeAcl) GetProcAddress (hAdvapi, "InitializeAcl");
     GNGetAce = (TGetAce) GetProcAddress (hAdvapi, "GetAce");
     GNEqualSid = (TEqualSid) GetProcAddress (hAdvapi, "EqualSid");
     GNAddAce = (TAddAce) GetProcAddress (hAdvapi, "AddAce");
-    GNAddAccessAllowedAce = (TAddAccessAllowedAce)
-        GetProcAddress (hAdvapi, "AddAccessAllowedAce");
-    GNSetNamedSecurityInfo = (TSetNamedSecurityInfo)
-        GetProcAddress (hAdvapi, "SetNamedSecurityInfoA");
+    GNAddAccessAllowedAce =
+        (TAddAccessAllowedAce) GetProcAddress (hAdvapi, "AddAccessAllowedAce");
+    GNSetNamedSecurityInfo =
+        (TSetNamedSecurityInfo) GetProcAddress (hAdvapi,
+                                                "SetNamedSecurityInfoA");
   }
   else
   {
@@ -215,8 +222,8 @@ GNInitWinEnv ()
   if (hNetapi)
   {
     GNNetUserAdd = (TNetUserAdd) GetProcAddress (hNetapi, "NetUserAdd");
-    GNNetUserSetInfo = (TNetUserSetInfo)
-        GetProcAddress (hNetapi, "NetUserSetInfo");
+    GNNetUserSetInfo =
+        (TNetUserSetInfo) GetProcAddress (hNetapi, "NetUserSetInfo");
   }
   else
   {