1 files changed, 341 insertions, 235 deletions

diff --git a/src/util/network.c b/src/util/network.c
index 6ce3df1c2..b533ce183 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -82,25 +82,27 @@ socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock)
 
 #if MINGW
   u_long mode;
+
   mode = !doBlock;
   if (ioctlsocket (fd->fd, FIONBIO, &mode) == SOCKET_ERROR)
 
-    {
-      SetErrnoFromWinsockError (WSAGetLastError ());
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");
-      return GNUNET_SYSERR;
-    }
+  {
+    SetErrnoFromWinsockError (WSAGetLastError ());
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 
 #else
   /* not MINGW */
   int flags = fcntl (fd->fd, F_GETFL);
+
   if (flags == -1)
 
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+    return GNUNET_SYSERR;
+  }
   if (doBlock)
     flags &= ~O_NONBLOCK;
 
@@ -108,10 +110,10 @@ socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock)
     flags |= O_NONBLOCK;
   if (0 != fcntl (fd->fd, F_SETFL, flags))
 
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 #endif
 }
@@ -130,7 +132,7 @@ socket_set_inheritable (const struct GNUNET_NETWORK_Handle *h)
 {
   int i;
 
-  i = fcntl (h->fd, F_GETFD);  
+  i = fcntl (h->fd, F_GETFD);
   if (i < 0)
     return GNUNET_SYSERR;
   if (i == (i | FD_CLOEXEC))
@@ -153,8 +155,10 @@ static void
 socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
 {
   int abs_value = 1;
+
   if (0 !=
-      setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE, &abs_value, sizeof (abs_value)))
+      setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE, &abs_value,
+                  sizeof (abs_value)))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
 }
 #endif
@@ -170,15 +174,19 @@ socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
 static void
 socket_set_nodelay (const struct GNUNET_NETWORK_Handle *h)
 {
-#ifndef WINDOWS  
+#ifndef WINDOWS
   int value = 1;
+
   if (0 != setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, &value, sizeof (value)))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
 #else
-  const char * abs_value = "1";
-  if (0 != setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, abs_value, sizeof (abs_value)))
+  const char *abs_value = "1";
+
+  if (0 !=
+      setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, abs_value,
+                  sizeof (abs_value)))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
-#endif  
+#endif
 }
 
 
@@ -192,8 +200,7 @@ socket_set_nodelay (const struct GNUNET_NETWORK_Handle *h)
  */
 struct GNUNET_NETWORK_Handle *
 GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
-                              struct sockaddr *address,
-                              socklen_t * address_len)
+                              struct sockaddr *address, socklen_t * address_len)
 {
   struct GNUNET_NETWORK_Handle *ret;
 
@@ -203,10 +210,11 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
     struct sockaddr name;
     int namelen = sizeof (name);
     int gsn = getsockname (desc->fd, &name, &namelen);
+
     if (gsn == 0)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-          "Accepting connection on `%s'\n",
-          GNUNET_a2s (&name, namelen));
+                  "Accepting connection on `%s'\n",
+                  GNUNET_a2s (&name, namelen));
   }
 #endif
   ret->fd = accept (desc->fd, address, address_len);
@@ -215,31 +223,31 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
   else
     ret->af = desc->af;
   if (ret->fd == INVALID_SOCKET)
-    {
+  {
 #ifdef MINGW
-      SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError (WSAGetLastError ());
 #endif
-      GNUNET_free (ret);
-      return NULL;
-    }
+    GNUNET_free (ret);
+    return NULL;
+  }
 #ifndef MINGW
   if (ret->fd >= FD_SETSIZE)
-    {
-      GNUNET_break (0 == close (ret->fd));
-      GNUNET_free (ret);
-      errno = EMFILE;
-      return NULL;
-    }
+  {
+    GNUNET_break (0 == close (ret->fd));
+    GNUNET_free (ret);
+    errno = EMFILE;
+    return NULL;
+  }
 #endif
   if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))
 
-    {
+  {
 
-      /* we might want to treat this one as fatal... */
-      GNUNET_break (0);
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));
-      return NULL;
-    }
+    /* we might want to treat this one as fatal... */
+    GNUNET_break (0);
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));
+    return NULL;
+  }
 
 #ifndef MINGW
   if (GNUNET_OK != socket_set_inheritable (ret))
@@ -270,10 +278,11 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
                             socklen_t address_len)
 {
   int ret;
-  
-#ifdef IPV6_V6ONLY 
+
+#ifdef IPV6_V6ONLY
 #ifdef IPPROTO_IPV6
   const int on = 1;
+
   if (desc->af == AF_INET6)
     if (0 != setsockopt (desc->fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on)))
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "setsockopt");
@@ -287,10 +296,11 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
 #ifndef LINUX
 #ifndef MINGW
   if (address->sa_family == AF_UNIX)
-    {
-      const struct sockaddr_un *un = (const struct sockaddr_un*) address;
-      (void) unlink (un->sun_path);
-    }
+  {
+    const struct sockaddr_un *un = (const struct sockaddr_un *) address;
+
+    (void) unlink (un->sun_path);
+  }
 #endif
 #endif
   ret = bind (desc->fd, address, address_len);
@@ -323,29 +333,33 @@ GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)
 
 #ifdef MINGW
   DWORD error = 0;
+
 #if DEBUG_NETWORK
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_NETWORK_socket_close", "Closing 0x%x\n", desc->fd);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_NETWORK_socket_close",
+                   "Closing 0x%x\n", desc->fd);
 #endif
   SetLastError (0);
   ret = closesocket (desc->fd);
   error = WSAGetLastError ();
   SetErrnoFromWinsockError (error);
 #if DEBUG_NETWORK
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_NETWORK_socket_close", "Closed 0x%x, closesocket() returned %d, GLE is %u\n", desc->fd, ret, error);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_NETWORK_socket_close",
+                   "Closed 0x%x, closesocket() returned %d, GLE is %u\n",
+                   desc->fd, ret, error);
 #endif
 #else
   ret = close (desc->fd);
 #endif
 #ifndef LINUX
 #ifndef MINGW
-  if ( (desc->af == AF_UNIX) && (NULL != desc->addr) )
-    {
-      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);
-    }
+  if ((desc->af == AF_UNIX) && (NULL != desc->addr))
+  {
+    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);
+  }
 #endif
 #endif
   GNUNET_free_non_null (desc->addr);
@@ -369,8 +383,8 @@ GNUNET_NETWORK_socket_box_native (int fd)
   struct GNUNET_NETWORK_Handle *ret;
 
   if (fcntl (fd, F_GETFD) < 0)
-    return NULL; /* invalid FD */
-  ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle)); 
+    return NULL;                /* invalid FD */
+  ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));
   ret->fd = fd;
   ret->af = AF_UNSPEC;
   return ret;
@@ -391,15 +405,16 @@ GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
                                socklen_t address_len)
 {
   int ret;
+
   ret = connect (desc->fd, address, address_len);
 
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    {
-      SetErrnoFromWinsockError (WSAGetLastError ());
-      if (errno == EWOULDBLOCK)
-        errno = EINPROGRESS;
-    }
+  {
+    SetErrnoFromWinsockError (WSAGetLastError ());
+    if (errno == EWOULDBLOCK)
+      errno = EINPROGRESS;
+  }
 #endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
@@ -421,6 +436,7 @@ GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,
                                   socklen_t * optlen)
 {
   int ret;
+
   ret = getsockopt (desc->fd, level, optname, optval, optlen);
 
 #ifdef MINGW
@@ -445,6 +461,7 @@ GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
                               int backlog)
 {
   int ret;
+
   ret = listen (desc->fd, backlog);
 
 #ifdef MINGW
@@ -464,17 +481,19 @@ GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
  */
 ssize_t
 GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle
-                                       *desc)
+                                       * desc)
 {
   int error;
 
   /* How much is there to be read? */
 #ifndef WINDOWS
   int pending;
+
   error = ioctl (desc->fd, FIONREAD, &pending);
   if (error == 0)
 #else
   u_long pending;
+
   error = ioctlsocket (desc->fd, FIONREAD, &pending);
   if (error != SOCKET_ERROR)
 #endif
@@ -496,11 +515,11 @@ GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle
 ssize_t
 GNUNET_NETWORK_socket_recvfrom (const struct GNUNET_NETWORK_Handle * desc,
                                 void *buffer, size_t length,
-                                struct sockaddr * src_addr,
-                                socklen_t * addrlen)
+                                struct sockaddr * src_addr, socklen_t * addrlen)
 {
   int ret;
   int flags;
+
   flags = 0;
 
 #ifdef MSG_DONTWAIT
@@ -511,7 +530,7 @@ GNUNET_NETWORK_socket_recvfrom (const struct GNUNET_NETWORK_Handle * desc,
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
     SetErrnoFromWinsockError (WSAGetLastError ());
-#endif 
+#endif
   return ret;
 }
 
@@ -528,6 +547,7 @@ GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,
 {
   int ret;
   int flags;
+
   flags = 0;
 
 #ifdef MSG_DONTWAIT
@@ -556,6 +576,7 @@ GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle * desc,
 {
   int ret;
   int flags;
+
   flags = 0;
 
 #ifdef MSG_DONTWAIT
@@ -596,6 +617,7 @@ GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,
 {
   int ret;
   int flags;
+
   flags = 0;
 
 #ifdef MSG_DONTWAIT
@@ -658,31 +680,31 @@ GNUNET_NETWORK_socket_create (int domain, int type, int protocol)
   ret->af = domain;
   ret->fd = socket (domain, type, protocol);
   if (INVALID_SOCKET == ret->fd)
-    {
+  {
 #ifdef MINGW
-      SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError (WSAGetLastError ());
 #endif
-      GNUNET_free (ret);
-      return NULL;
-    }
+    GNUNET_free (ret);
+    return NULL;
+  }
 
 #ifndef MINGW
   if (ret->fd >= FD_SETSIZE)
-    {
-      GNUNET_break (0 == close (ret->fd));
-      GNUNET_free (ret);
-      errno = EMFILE;
-      return NULL;
-    }
+  {
+    GNUNET_break (0 == close (ret->fd));
+    GNUNET_free (ret);
+    errno = EMFILE;
+    return NULL;
+  }
 
 #endif
   if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))
-    {
-      /* we might want to treat this one as fatal... */
-      GNUNET_break (0);
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));
-      return NULL;
-    }
+  {
+    /* we might want to treat this one as fatal... */
+    GNUNET_break (0);
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));
+    return NULL;
+  }
 
 #ifndef MINGW
   if (GNUNET_OK != socket_set_inheritable (ret))
@@ -692,11 +714,11 @@ GNUNET_NETWORK_socket_create (int domain, int type, int protocol)
 #ifdef DARWIN
   socket_set_nosigpipe (ret);
 #endif
-  if ( (type == SOCK_STREAM) 
+  if ((type == SOCK_STREAM)
 #ifdef AF_UNIX
-       && (domain != AF_UNIX) 
+      && (domain != AF_UNIX)
 #endif
-       )
+      )
     socket_set_nodelay (ret);
   return ret;
 }
@@ -736,15 +758,26 @@ GNUNET_NETWORK_socket_disable_corking (struct GNUNET_NETWORK_Handle *desc)
 {
   int value = 0;
   int ret = 0;
+
 #if WINDOWS
-  if (0 != (ret = setsockopt (desc->fd, SOL_SOCKET, SO_SNDBUF, (char *) &value, sizeof (value))))
+  if (0 !=
+      (ret =
+       setsockopt (desc->fd, SOL_SOCKET, SO_SNDBUF, (char *) &value,
+                   sizeof (value))))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
-  if (0 != (ret = setsockopt (desc->fd, SOL_SOCKET, SO_RCVBUF, (char *) &value, sizeof (value))))
+  if (0 !=
+      (ret =
+       setsockopt (desc->fd, SOL_SOCKET, SO_RCVBUF, (char *) &value,
+                   sizeof (value))))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
 #else
-  if (0 != (ret = setsockopt (desc->fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof (value))))
+  if (0 !=
+      (ret =
+       setsockopt (desc->fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof (value))))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
-  if (0 != (ret = setsockopt (desc->fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof (value))))
+  if (0 !=
+      (ret =
+       setsockopt (desc->fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof (value))))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
 #endif
 
@@ -805,14 +838,15 @@ GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,
                           const struct GNUNET_NETWORK_FDSet *src)
 {
   int nfds;
+
   for (nfds = src->nsds; nfds > 0; nfds--)
     if (FD_ISSET (nfds, &src->sds))
 
-      {
-        FD_SET (nfds, &dst->sds);
-        if (nfds + 1 > dst->nsds)
-          dst->nsds = nfds + 1;
-      }
+    {
+      FD_SET (nfds, &dst->sds);
+      if (nfds + 1 > dst->nsds)
+        dst->nsds = nfds + 1;
+    }
 #ifdef MINGW
   GNUNET_CONTAINER_slist_append (dst->handles, src->handles);
 #endif
@@ -874,10 +908,10 @@ GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,
  * @param to destination
  * @param nfd native FD to set
  */
-void GNUNET_NETWORK_fdset_set_native (struct GNUNET_NETWORK_FDSet *to,
-                                      int nfd)
+void
+GNUNET_NETWORK_fdset_set_native (struct GNUNET_NETWORK_FDSet *to, int nfd)
 {
-  GNUNET_assert((nfd >= 0) && (nfd < FD_SETSIZE));
+  GNUNET_assert ((nfd >= 0) && (nfd < FD_SETSIZE));
   FD_SET (nfd, &to->sds);
   to->nsds = GNUNET_MAX (nfd + 1, to->nsds);
 }
@@ -890,11 +924,11 @@ void GNUNET_NETWORK_fdset_set_native (struct GNUNET_NETWORK_FDSet *to,
  * @param nfd native FD to test, or -1 for none
  * @return GNUNET_YES if FD is set in the set
  */
-int 
+int
 GNUNET_NETWORK_fdset_test_native (const struct GNUNET_NETWORK_FDSet *to,
-                                  int nfd)
+                                  int nfd)
 {
-  if ( (nfd == -1) || (to == NULL) )
+  if ((nfd == -1) || (to == NULL))
     return GNUNET_NO;
   return FD_ISSET (nfd, &to->sds) ? GNUNET_YES : GNUNET_NO;
 }
@@ -916,6 +950,7 @@ GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,
 
 #else
   int fd;
+
   GNUNET_DISK_internal_file_handle_ (h, &fd, sizeof (int));
   FD_SET (fd, &fds->sds);
   if (fd + 1 > fds->nsds)
@@ -938,7 +973,8 @@ GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,
 
 #ifdef MINGW
   return GNUNET_CONTAINER_slist_contains (fds->handles, h,
-                                          sizeof (struct GNUNET_DISK_FileHandle));
+                                          sizeof (struct
+                                                  GNUNET_DISK_FileHandle));
 #else
   return FD_ISSET (h->fd, &fds->sds);
 #endif
@@ -962,11 +998,11 @@ GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
   if (nfds > fds2->nsds)
     nfds = fds2->nsds;
   while (nfds > 0)
-    {
-      nfds--;
-      if (FD_ISSET (nfds, &fds1->sds) && FD_ISSET (nfds, &fds2->sds))
-        return GNUNET_YES;
-    }
+  {
+    nfds--;
+    if (FD_ISSET (nfds, &fds1->sds) && FD_ISSET (nfds, &fds2->sds))
+      return GNUNET_YES;
+  }
 #else
   struct GNUNET_CONTAINER_SList_Iterator *it;
   struct GNUNET_DISK_FileHandle *h;
@@ -974,7 +1010,7 @@ GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
   int j;
 
   /*This code is somewhat hacky, we are not supposed to know what's
-    inside of fd_set; also the O(n^2) is really bad... */
+   * inside of fd_set; also the O(n^2) is really bad... */
 
   for (i = 0; i < fds1->sds.fd_count; i++)
   {
@@ -986,33 +1022,36 @@ GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
   }
   it = GNUNET_CONTAINER_slist_begin (fds1->handles);
   while (GNUNET_CONTAINER_slist_end (it) != GNUNET_YES)
-    {
+  {
 #if DEBUG_NETWORK
-      struct GNUNET_CONTAINER_SList_Iterator *t;
+    struct GNUNET_CONTAINER_SList_Iterator *t;
 #endif
-      h = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (it, NULL);
+    h = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (it, NULL);
 #if DEBUG_NETWORK
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking that FD 0x%x is in another set:\n", h->h);
-      for (t = GNUNET_CONTAINER_slist_begin (fds2->handles);
-          GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-          GNUNET_CONTAINER_slist_next (t))
-      {
-        struct GNUNET_DISK_FileHandle *fh;
-        fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t, NULL);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "0x%x\n", fh->h);
-      }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Checking that FD 0x%x is in another set:\n", h->h);
+    for (t = GNUNET_CONTAINER_slist_begin (fds2->handles);
+         GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+         GNUNET_CONTAINER_slist_next (t))
+    {
+      struct GNUNET_DISK_FileHandle *fh;
+
+      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t,
+                                                                         NULL);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "0x%x\n", fh->h);
+    }
 #endif
-      if (GNUNET_CONTAINER_slist_contains
-          (fds2->handles, h, sizeof (struct GNUNET_DISK_FileHandle)))
-        {
+    if (GNUNET_CONTAINER_slist_contains
+        (fds2->handles, h, sizeof (struct GNUNET_DISK_FileHandle)))
+    {
 #if DEBUG_NETWORK
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Match!\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Match!\n");
 #endif
-          GNUNET_CONTAINER_slist_iter_destroy (it);
-          return GNUNET_YES;
-        }
-      GNUNET_CONTAINER_slist_next (it);
+      GNUNET_CONTAINER_slist_iter_destroy (it);
+      return GNUNET_YES;
     }
+    GNUNET_CONTAINER_slist_next (it);
+  }
   GNUNET_CONTAINER_slist_iter_destroy (it);
 #endif
   return GNUNET_NO;
@@ -1027,6 +1066,7 @@ struct GNUNET_NETWORK_FDSet *
 GNUNET_NETWORK_fdset_create ()
 {
   struct GNUNET_NETWORK_FDSet *fds;
+
   fds = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_FDSet));
 #ifdef MINGW
   fds->handles = GNUNET_CONTAINER_slist_create ();
@@ -1064,6 +1104,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
                               const struct GNUNET_TIME_Relative timeout)
 {
   int nfds = 0;
+
 #ifdef MINGW
   int handles = 0;
   int ex_handles = 0;
@@ -1093,6 +1134,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   struct GNUNET_CONTAINER_SList *handles_read, *handles_write, *handles_except;
 
   fd_set aread, awrite, aexcept;
+
 #if DEBUG_NETWORK
   fd_set bread, bwrite, bexcept;
 #endif
@@ -1103,62 +1145,67 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   struct timeval tv;
 #endif
   if (NULL != rfds)
-    {
-      nfds = rfds->nsds;
+  {
+    nfds = rfds->nsds;
 #ifdef MINGW
-      handles += read_handles = GNUNET_CONTAINER_slist_count (rfds->handles);
+    handles += read_handles = GNUNET_CONTAINER_slist_count (rfds->handles);
 #if DEBUG_NETWORK
+    {
+      struct GNUNET_CONTAINER_SList_Iterator *t;
+
+      for (t = GNUNET_CONTAINER_slist_begin (rfds->handles);
+           GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+           GNUNET_CONTAINER_slist_next (t))
       {
-        struct GNUNET_CONTAINER_SList_Iterator *t;
-        for (t = GNUNET_CONTAINER_slist_begin (rfds->handles);
-            GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-            GNUNET_CONTAINER_slist_next (t))
-        {
-          struct GNUNET_DISK_FileHandle *fh;
-          fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t, NULL);
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x (0x%x) is SET in rfds\n", fh->h, fh);
-        }
+        struct GNUNET_DISK_FileHandle *fh;
+
+        fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t,
+                                                                           NULL);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x (0x%x) is SET in rfds\n",
+                    fh->h, fh);
       }
+    }
 #endif
 #endif
-    }
+  }
   if (NULL != wfds)
-    {
-      nfds = GNUNET_MAX (nfds, wfds->nsds);
+  {
+    nfds = GNUNET_MAX (nfds, wfds->nsds);
 #ifdef MINGW
-      handles += write_handles = GNUNET_CONTAINER_slist_count (wfds->handles);
+    handles += write_handles = GNUNET_CONTAINER_slist_count (wfds->handles);
 #endif
-    }
+  }
   if (NULL != efds)
-    {
-      nfds = GNUNET_MAX (nfds, efds->nsds);
+  {
+    nfds = GNUNET_MAX (nfds, efds->nsds);
 #ifdef MINGW
-      handles += ex_handles = GNUNET_CONTAINER_slist_count (efds->handles);
+    handles += ex_handles = GNUNET_CONTAINER_slist_count (efds->handles);
 #endif
-    }
+  }
 
-  if ((nfds == 0) && (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+  if ((nfds == 0) &&
+      (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
 #ifdef MINGW
       && handles == 0
 #endif
-    )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
-                  "select");
-      GNUNET_break (0);
-    }
+      )
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
+                "select");
+    GNUNET_break (0);
+  }
 #ifndef MINGW
   tv.tv_sec = timeout.rel_value / GNUNET_TIME_UNIT_SECONDS.rel_value;
   tv.tv_usec =
-    1000 * (timeout.rel_value - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value));
-  return select (nfds,
-                 (rfds != NULL) ? &rfds->sds : NULL,
+      1000 * (timeout.rel_value -
+              (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value));
+  return select (nfds, (rfds != NULL) ? &rfds->sds : NULL,
                  (wfds != NULL) ? &wfds->sds : NULL,
                  (efds != NULL) ? &efds->sds : NULL,
-                 (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
-                 ? NULL : &tv);
+                 (timeout.rel_value ==
+                  GNUNET_TIME_UNIT_FOREVER_REL.rel_value) ? NULL : &tv);
 
 #else
 #define SAFE_FD_ISSET(fd, set)  (set != NULL && FD_ISSET(fd, set))
@@ -1169,10 +1216,10 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     ms_total = timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value;
   /* select() may be used as a portable way to sleep */
   if (!(rfds || wfds || efds))
-    {
-      Sleep (ms_total);
-      return 0;
-    }
+  {
+    Sleep (ms_total);
+    return 0;
+  }
 
   /* Events for sockets */
   if (!hEventRead)
@@ -1195,7 +1242,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     hEventPipeWrite = CreateEvent (NULL, TRUE, TRUE, NULL);
   readPipes = 0;
   writePipePos = -1;
-  
+
   handles_read = GNUNET_CONTAINER_slist_create ();
   handles_write = GNUNET_CONTAINER_slist_create ();
   handles_except = GNUNET_CONTAINER_slist_create ();
@@ -1233,40 +1280,49 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   if (rfds && read_handles)
   {
     struct GNUNET_CONTAINER_SList_Iterator *i;
+
     for (i = GNUNET_CONTAINER_slist_begin (rfds->handles);
-        GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;
-        GNUNET_CONTAINER_slist_next (i))
+         GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;
+         GNUNET_CONTAINER_slist_next (i))
     {
       struct GNUNET_DISK_FileHandle *fh;
-      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (i, NULL);
+
+      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (i,
+                                                                         NULL);
       if (fh->type == GNUNET_PIPE)
       {
         /* Read zero bytes to check the status of the pipe */
 #if DEBUG_NETWORK
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reading 0 bytes from the pipe 0x%x\n", fh->h);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Reading 0 bytes from the pipe 0x%x\n", fh->h);
 #endif
         if (!ReadFile (fh->h, NULL, 0, NULL, fh->oOverlapRead))
         {
-          DWORD error_code = GetLastError();
+          DWORD error_code = GetLastError ();
+
           if (error_code == ERROR_IO_PENDING)
           {
 #if DEBUG_NETWORK
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the pipe's 0x%x overlapped event to the array as %d\n", fh->h, nhandles);
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Adding the pipe's 0x%x overlapped event to the array as %d\n",
+                        fh->h, nhandles);
 #endif
             handle_array[nhandles++] = fh->oOverlapRead->hEvent;
             readArray[readPipes++] = fh;
           }
           /*
-          else
-          {
-            SetErrnoFromWinError (error_code);
-          }
-          */
+           * else
+           * {
+           * SetErrnoFromWinError (error_code);
+           * }
+           */
         }
         else
         {
 #if DEBUG_NETWORK
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the read ready event to the array as %d\n", nhandles);
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Adding the read ready event to the array as %d\n",
+                      nhandles);
 #endif
           handle_array[nhandles++] = hEventReadReady;
           readArray[readPipes++] = fh;
@@ -1275,8 +1331,8 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
       else
       {
         GNUNET_CONTAINER_slist_add (handles_read,
-            GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-            fh, sizeof (struct GNUNET_DISK_FileHandle));
+                                    GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                    fh, sizeof (struct GNUNET_DISK_FileHandle));
       }
     }
     GNUNET_CONTAINER_slist_iter_destroy (i);
@@ -1284,7 +1340,8 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   if (wfds && write_handles)
   {
 #if DEBUG_NETWORK
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the write ready event to the array as %d\n", nhandles);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Adding the write ready event to the array as %d\n", nhandles);
 #endif
     handle_array[nhandles++] = hEventPipeWrite;
     writePipePos = nhandles;
@@ -1292,21 +1349,24 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   if (efds && ex_handles)
   {
     struct GNUNET_CONTAINER_SList_Iterator *i;
+
     for (i = GNUNET_CONTAINER_slist_begin (efds->handles);
-        GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;
-        GNUNET_CONTAINER_slist_next (i))
+         GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;
+         GNUNET_CONTAINER_slist_next (i))
     {
       struct GNUNET_DISK_FileHandle *fh;
       DWORD dwBytes;
 
-      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (i, NULL);
+      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (i,
+                                                                         NULL);
       if (fh->type == GNUNET_PIPE)
       {
         if (!PeekNamedPipe (fh->h, NULL, 0, NULL, &dwBytes, NULL))
         {
           GNUNET_CONTAINER_slist_add (handles_except,
-              GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-              fh, sizeof (struct GNUNET_DISK_FileHandle));
+                                      GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                      fh,
+                                      sizeof (struct GNUNET_DISK_FileHandle));
           newretcode++;
         }
       }
@@ -1318,21 +1378,27 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     if (rfds)
     {
 #if DEBUG_NETWORK
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the socket read event to the array as %d\n", nhandles);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Adding the socket read event to the array as %d\n",
+                  nhandles);
 #endif
       handle_array[nhandles++] = hEventRead;
       nSockEvents++;
       for (i = 0; i < rfds->sds.fd_count; i++)
       {
-        WSAEventSelect (rfds->sds.fd_array[i], hEventRead, FD_ACCEPT | FD_READ | FD_CLOSE);
+        WSAEventSelect (rfds->sds.fd_array[i], hEventRead,
+                        FD_ACCEPT | FD_READ | FD_CLOSE);
         nsock++;
       }
     }
     if (wfds)
     {
       int wakeup = 0;
+
 #if DEBUG_NETWORK
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the socket write event to the array as %d\n", nhandles);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Adding the socket write event to the array as %d\n",
+                  nhandles);
 #endif
       handle_array[nhandles++] = hEventWrite;
       nSockEvents++;
@@ -1340,14 +1406,18 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
       {
         DWORD error;
         int status;
+
         status = send (wfds->sds.fd_array[i], NULL, 0, 0);
         error = GetLastError ();
 #if DEBUG_NETWORK
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pre-send to the socket %d returned %d (%u)\n", i, status, error);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "pre-send to the socket %d returned %d (%u)\n", i, status,
+                    error);
 #endif
         if (status == 0 || (error != WSAEWOULDBLOCK && error != WSAENOTCONN))
           wakeup = 1;
-        WSAEventSelect (wfds->sds.fd_array[i], hEventWrite, FD_WRITE | FD_CONNECT | FD_CLOSE);
+        WSAEventSelect (wfds->sds.fd_array[i], hEventWrite,
+                        FD_WRITE | FD_CONNECT | FD_CLOSE);
         nsock++;
       }
       if (wakeup)
@@ -1356,13 +1426,16 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     if (efds)
     {
 #if DEBUG_NETWORK
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the socket error event to the array as %d\n", nhandles);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Adding the socket error event to the array as %d\n",
+                  nhandles);
 #endif
       handle_array[nhandles++] = hEventException;
       nSockEvents++;
       for (i = 0; i < efds->sds.fd_count; i++)
       {
-        WSAEventSelect (efds->sds.fd_array[i], hEventException, FD_OOB | FD_CLOSE);
+        WSAEventSelect (efds->sds.fd_array[i], hEventException,
+                        FD_OOB | FD_CLOSE);
         nsock++;
       }
     }
@@ -1378,11 +1451,13 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 #endif
 
   if (nhandles)
-    returncode = WaitForMultipleObjects (nhandles, handle_array, FALSE, ms_total); 
+    returncode =
+        WaitForMultipleObjects (nhandles, handle_array, FALSE, ms_total);
 #if DEBUG_NETWORK
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "WaitForMultipleObjects Returned : %d\n", returncode);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "WaitForMultipleObjects Returned : %d\n",
+              returncode);
 #endif
-  
+
   returnedpos = returncode - WAIT_OBJECT_0;
 #if DEBUG_NETWORK
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "return pos is : %d\n", returnedpos);
@@ -1390,16 +1465,18 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 
   /* FIXME: THIS LINE IS WRONG !! We should add to handles only handles that fired the events, not all ! */
   /*
-  if(rfds)
-    GNUNET_CONTAINER_slist_append (handles_read, rfds->handles);
-  */
+   * if(rfds)
+   * GNUNET_CONTAINER_slist_append (handles_read, rfds->handles);
+   */
   if (nhandles && (returnedpos < nhandles))
   {
     DWORD waitstatus;
+
     /* Do the select */
     if (nfds)
     {
       struct timeval tvslice;
+
       tvslice.tv_sec = 0;
       tvslice.tv_usec = 10;
       retcode = select (nfds, &aread, &awrite, &aexcept, &tvslice);
@@ -1423,48 +1500,55 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 #endif
     /* We have some pipes ready for read. */
     /* FIXME: it is supposed to work !! Only choose the Pipes who fired the event, but it is not working */
-    
+
     if (returnedpos < readPipes)
     {
       /*
-      for (i = 0; i < readPipes; i++)
-      {
-        waitstatus = WaitForSingleObject (handle_array[i], 0);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read pipe %d wait status is : %d\n", i, waitstatus);
-        if (waitstatus != WAIT_OBJECT_0)
-          continue;
-        GNUNET_CONTAINER_slist_add (handles_read,
-            GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-            readArray[i], sizeof (struct GNUNET_DISK_FileHandle));
-        retcode++;
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added read Pipe\n");
-      }
-      */
+       * for (i = 0; i < readPipes; i++)
+       * {
+       * waitstatus = WaitForSingleObject (handle_array[i], 0);
+       * GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read pipe %d wait status is : %d\n", i, waitstatus);
+       * if (waitstatus != WAIT_OBJECT_0)
+       * continue;
+       * GNUNET_CONTAINER_slist_add (handles_read,
+       * GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+       * readArray[i], sizeof (struct GNUNET_DISK_FileHandle));
+       * retcode++;
+       * GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added read Pipe\n");
+       * }
+       */
       for (i = 0; i < readPipes; i++)
       {
         DWORD error;
         BOOL bret;
+
         SetLastError (0);
         waitstatus = 0;
-        bret = PeekNamedPipe (readArray[i]->h, NULL, 0, NULL, &waitstatus, NULL);
+        bret =
+            PeekNamedPipe (readArray[i]->h, NULL, 0, NULL, &waitstatus, NULL);
         error = GetLastError ();
 #if DEBUG_NETWORK
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peek at read pipe %d (0x%x) returned %d (%d bytes available) GLE %u\n", i, readArray[i]->h, bret, waitstatus, error);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Peek at read pipe %d (0x%x) returned %d (%d bytes available) GLE %u\n",
+                    i, readArray[i]->h, bret, waitstatus, error);
 #endif
         if (bret == 0 || waitstatus <= 0)
           continue;
         GNUNET_CONTAINER_slist_add (handles_read,
-            GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-            readArray[i], sizeof (struct GNUNET_DISK_FileHandle));
+                                    GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                    readArray[i],
+                                    sizeof (struct GNUNET_DISK_FileHandle));
         retcode++;
 #if DEBUG_NETWORK
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added read Pipe 0x%x (0x%x)\n", readArray[i], readArray[i]->h);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added read Pipe 0x%x (0x%x)\n",
+                    readArray[i], readArray[i]->h);
 #endif
       }
     }
     waitstatus = WaitForSingleObject (hEventWrite, 0);
 #if DEBUG_NETWORK
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Wait for the write event returned %d\n", waitstatus);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Wait for the write event returned %d\n", waitstatus);
 #endif
     if (waitstatus == WAIT_OBJECT_0)
     {
@@ -1474,15 +1558,21 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
         int status;
         int so_error = 0;
         int sizeof_so_error = sizeof (so_error);
-        int gso_result = getsockopt (wfds->sds.fd_array[i], SOL_SOCKET, SO_ERROR, (char *) &so_error, &sizeof_so_error);
+        int gso_result =
+            getsockopt (wfds->sds.fd_array[i], SOL_SOCKET, SO_ERROR,
+                        (char *) &so_error, &sizeof_so_error);
+
         status = send (wfds->sds.fd_array[i], NULL, 0, 0);
         error = GetLastError ();
 #if DEBUG_NETWORK
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "send to the socket %d returned %d (%u)\n", i, status, error);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "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))
+            || (status == -1 && gso_result == 0 && error == WSAENOTCONN &&
+                so_error == WSAECONNREFUSED))
         {
           FD_SET (wfds->sds.fd_array[i], &awrite);
           retcode += 1;
@@ -1492,22 +1582,26 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   }
 #if DEBUG_NETWORK
   if (!nhandles || (returnedpos >= nhandles))
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Returning from _select() with nothing!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Returning from _select() with nothing!\n");
 #endif
   if (rfds)
   {
     struct GNUNET_CONTAINER_SList_Iterator *t;
+
     for (i = 0; i < rfds->sds.fd_count; i++)
     {
       WSAEventSelect (rfds->sds.fd_array[i], hEventRead, 0);
       nsock++;
     }
     for (t = GNUNET_CONTAINER_slist_begin (rfds->handles);
-        GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-        GNUNET_CONTAINER_slist_next (t))
+         GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+         GNUNET_CONTAINER_slist_next (t))
     {
       struct GNUNET_DISK_FileHandle *fh;
-      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t, NULL);
+
+      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t,
+                                                                         NULL);
       if (fh->type == GNUNET_PIPE)
       {
         CancelIo (fh->h);
@@ -1559,17 +1653,23 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   if (rfds)
   {
     struct GNUNET_CONTAINER_SList_Iterator *t;
+
     for (i = 0; i < bread.fd_count; i++)
     {
       if (bread.fd_array[i] != 0)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x is %s in rfds\n", bread.fd_array[i], (SAFE_FD_ISSET (bread.fd_array[i], rfds)) ? "SET" : "NOT SET");
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x is %s in rfds\n",
+                    bread.fd_array[i],
+                    (SAFE_FD_ISSET (bread.fd_array[i], rfds)) ? "SET" :
+                    "NOT SET");
     }
     for (t = GNUNET_CONTAINER_slist_begin (rfds->handles);
-        GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-        GNUNET_CONTAINER_slist_next (t))
+         GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+         GNUNET_CONTAINER_slist_next (t))
     {
       struct GNUNET_DISK_FileHandle *fh;
-      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t, NULL);
+
+      fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t,
+                                                                         NULL);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x is SET in rfds\n", fh->h);
     }
   }
@@ -1578,7 +1678,10 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     for (i = 0; i < bwrite.fd_count; i++)
     {
       if (bwrite.fd_array[i] != 0)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x is %s in wfds\n", bwrite.fd_array[i], (SAFE_FD_ISSET (bwrite.fd_array[i], rfds)) ? "SET" : "NOT SET");
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x is %s in wfds\n",
+                    bwrite.fd_array[i],
+                    (SAFE_FD_ISSET (bwrite.fd_array[i], rfds)) ? "SET" :
+                    "NOT SET");
     }
   }
   if (efds)
@@ -1586,7 +1689,10 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     for (i = 0; i < bexcept.fd_count; i++)
     {
       if (bexcept.fd_array[i] != 0)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x is %s in efds\n", bexcept.fd_array[i], (SAFE_FD_ISSET (bexcept.fd_array[i], rfds)) ? "SET" : "NOT SET");
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FD 0x%x is %s in efds\n",
+                    bexcept.fd_array[i],
+                    (SAFE_FD_ISSET (bexcept.fd_array[i], rfds)) ? "SET" :
+                    "NOT SET");
     }
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Returning %d or 0\n", retcode);