1 files changed, 401 insertions, 419 deletions

diff --git a/src/util/server.c b/src/util/server.c
index 6e2dc32cf..935cf04f8 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -242,7 +242,7 @@ struct GNUNET_SERVER_Client
    * be used in special cases!
    */
   int persist;
-  
+
   /**
    * Type of last message processed (for warn_no_receive_done).
    */
@@ -258,8 +258,7 @@ struct GNUNET_SERVER_Client
  * @param tc reason why we are running right now
  */
 static void
-process_listen_socket (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+process_listen_socket (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_SERVER_Handle *server = cls;
   struct GNUNET_CONNECTION_Handle *sock;
@@ -273,49 +272,46 @@ process_listen_socket (void *cls,
   while (NULL != server->listen_sockets[i])
     GNUNET_NETWORK_fdset_set (r, server->listen_sockets[i++]);
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    {
-      /* ignore shutdown, someone else will take care of it! */
-      server->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                                         GNUNET_SCHEDULER_NO_TASK,
-                                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                                         r, NULL,
-                                                         &process_listen_socket,
-                                                         server);
-      GNUNET_NETWORK_fdset_destroy (r);
-      return;
-    }
+  {
+    /* ignore shutdown, someone else will take care of it! */
+    server->listen_task =
+        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
+                                     &process_listen_socket, server);
+    GNUNET_NETWORK_fdset_destroy (r);
+    return;
+  }
   i = 0;
   while (NULL != server->listen_sockets[i])
+  {
+    if (GNUNET_NETWORK_fdset_isset (tc->read_ready, server->listen_sockets[i]))
     {
-      if (GNUNET_NETWORK_fdset_isset
-          (tc->read_ready, server->listen_sockets[i]))
-        {
-          sock =
-            GNUNET_CONNECTION_create_from_accept (server->access,
-                                                  server->access_cls,
-                                                  server->listen_sockets[i]);
-          if (sock != NULL)
-            {
+      sock =
+          GNUNET_CONNECTION_create_from_accept (server->access,
+                                                server->access_cls,
+                                                server->listen_sockets[i]);
+      if (sock != NULL)
+      {
 #if DEBUG_SERVER
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Server accepted incoming connection.\n");
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Server accepted incoming connection.\n");
 #endif
-              client = GNUNET_SERVER_connect_socket (server, sock);
-              GNUNET_CONNECTION_ignore_shutdown (sock,
-                                                 server->clients_ignore_shutdown);
-              /* decrement reference count, we don't keep "client" alive */
-              GNUNET_SERVER_client_drop (client);
-            }
-        }
-      i++;
+        client = GNUNET_SERVER_connect_socket (server, sock);
+        GNUNET_CONNECTION_ignore_shutdown (sock,
+                                           server->clients_ignore_shutdown);
+        /* decrement reference count, we don't keep "client" alive */
+        GNUNET_SERVER_client_drop (client);
+      }
     }
+    i++;
+  }
   /* listen for more! */
-  server->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                                     GNUNET_SCHEDULER_NO_TASK,
-                                                     GNUNET_TIME_UNIT_FOREVER_REL,
-                                                     r, NULL,
-                                                     &process_listen_socket,
-                                                     server);
+  server->listen_task =
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
+                                   &process_listen_socket, server);
   GNUNET_NETWORK_fdset_destroy (r);
 }
 
@@ -336,88 +332,88 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
   int eno;
 
   switch (serverAddr->sa_family)
-    {
-    case AF_INET:
-      port = ntohs (((const struct sockaddr_in *) serverAddr)->sin_port);
-      break;
-    case AF_INET6:
-      port = ntohs (((const struct sockaddr_in6 *) serverAddr)->sin6_port);
-      break;
-    case AF_UNIX:
-      port = 0;
-      break;
-    default:
-      GNUNET_break (0);
-      port = 0;
-      break;
-    }
+  {
+  case AF_INET:
+    port = ntohs (((const struct sockaddr_in *) serverAddr)->sin_port);
+    break;
+  case AF_INET6:
+    port = ntohs (((const struct sockaddr_in6 *) serverAddr)->sin6_port);
+    break;
+  case AF_UNIX:
+    port = 0;
+    break;
+  default:
+    GNUNET_break (0);
+    port = 0;
+    break;
+  }
   sock = GNUNET_NETWORK_socket_create (serverAddr->sa_family, SOCK_STREAM, 0);
   if (NULL == sock)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
-      errno = 0;
-      return NULL;
-    }
-  if (port != 0) 
-    {
-      if (GNUNET_NETWORK_socket_setsockopt
-          (sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                             "setsockopt");
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+    errno = 0;
+    return NULL;
+  }
+  if (port != 0)
+  {
+    if (GNUNET_NETWORK_socket_setsockopt
+        (sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                           "setsockopt");
 #ifdef IPV6_V6ONLY
-      if ( (serverAddr->sa_family == AF_INET6) &&
-           (GNUNET_NETWORK_socket_setsockopt
-            (sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on)) != GNUNET_OK) )
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                             "setsockopt");
+    if ((serverAddr->sa_family == AF_INET6) &&
+        (GNUNET_NETWORK_socket_setsockopt
+         (sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on)) != GNUNET_OK))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                           "setsockopt");
 #endif
-    }
+  }
   /* bind the socket */
   if (GNUNET_NETWORK_socket_bind (sock, serverAddr, socklen) != GNUNET_OK)
+  {
+    eno = errno;
+    if (errno != EADDRINUSE)
     {
-      eno = errno;
-      if (errno != EADDRINUSE)
-        {
-          /* we don't log 'EADDRINUSE' here since an IPv4 bind may
-             fail if we already took the port on IPv6; if both IPv4 and
-             IPv6 binds fail, then our caller will log using the
-             errno preserved in 'eno' */
-          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,
-                        (serverAddr->sa_family == AF_INET) ? "IPv4" : "IPv6");
-          eno = 0;
-        }
-      else
-        {
-          if (port != 0)
-            GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                        _
-                        ("`%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", 
-                        ((const struct sockaddr_un*) serverAddr)->sun_path);
-
-        }
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
-      errno = eno;
-      return NULL;
+      /* we don't log 'EADDRINUSE' here since an IPv4 bind may
+       * fail if we already took the port on IPv6; if both IPv4 and
+       * IPv6 binds fail, then our caller will log using the
+       * errno preserved in 'eno' */
+      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,
+                    (serverAddr->sa_family == AF_INET) ? "IPv4" : "IPv6");
+      eno = 0;
     }
-  if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
+    else
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
-      errno = 0;
-      return NULL;
+      if (port != 0)
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _
+                    ("`%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",
+                    ((const struct sockaddr_un *) serverAddr)->sun_path);
+
     }
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
+    errno = eno;
+    return NULL;
+  }
+  if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
+    errno = 0;
+    return NULL;
+  }
 #if DEBUG_SERVER
   if (port != 0)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -440,11 +436,11 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
  *         (typically, "port" already in use)
  */
 struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
-                                   struct GNUNET_NETWORK_Handle **lsocks,
-                                   struct GNUNET_TIME_Relative
-                                   idle_timeout,
-                                   int require_found)
+GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
+                                   void *access_cls,
+                                   struct GNUNET_NETWORK_Handle **lsocks,
+                                   struct GNUNET_TIME_Relative idle_timeout,
+                                   int require_found)
 {
   struct GNUNET_SERVER_Handle *ret;
   struct GNUNET_NETWORK_FDSet *r;
@@ -457,19 +453,18 @@ GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access, void *a
   ret->access_cls = access_cls;
   ret->require_found = require_found;
   if (lsocks != NULL)
-    {
-      r = GNUNET_NETWORK_fdset_create ();
-      i = 0;
-      while (NULL != ret->listen_sockets[i])
-        GNUNET_NETWORK_fdset_set (r, ret->listen_sockets[i++]);
-      ret->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                                      GNUNET_SCHEDULER_NO_TASK,
-                                                      GNUNET_TIME_UNIT_FOREVER_REL,
-                                                      r, NULL,
-                                                      &process_listen_socket,
-                                                      ret);
-      GNUNET_NETWORK_fdset_destroy (r);
-    }
+  {
+    r = GNUNET_NETWORK_fdset_create ();
+    i = 0;
+    while (NULL != ret->listen_sockets[i])
+      GNUNET_NETWORK_fdset_set (r, ret->listen_sockets[i++]);
+    ret->listen_task =
+        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
+                                     &process_listen_socket, ret);
+    GNUNET_NETWORK_fdset_destroy (r);
+  }
   return ret;
 }
 
@@ -503,34 +498,32 @@ GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access,
   while (serverAddr[i] != NULL)
     i++;
   if (i > 0)
+  {
+    lsocks = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (i + 1));
+    i = 0;
+    j = 0;
+    while (serverAddr[i] != NULL)
     {
-      lsocks =
-        GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (i + 1));
-      i = 0;
-      j = 0;
-      while (serverAddr[i] != NULL)
-        {
-          lsocks[j] = open_listen_socket (serverAddr[i], socklen[i]);
-          if (lsocks[j] != NULL)
-            j++;
-          i++;
-        }
-      if (j == 0)
-        {
-          if (errno != 0)
-            GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");          
-          GNUNET_free (lsocks);
-          lsocks = NULL;
-        }
+      lsocks[j] = open_listen_socket (serverAddr[i], socklen[i]);
+      if (lsocks[j] != NULL)
+        j++;
+      i++;
     }
-  else
+    if (j == 0)
     {
+      if (errno != 0)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+      GNUNET_free (lsocks);
       lsocks = NULL;
     }
+  }
+  else
+  {
+    lsocks = NULL;
+  }
   return GNUNET_SERVER_create_with_sockets (access, access_cls,
-                                            lsocks,
-                                            idle_timeout,
-                                            require_found);
+                                            lsocks,
+                                            idle_timeout, require_found);
 }
 
 
@@ -550,32 +543,32 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server shutting down.\n");
 #endif
   if (GNUNET_SCHEDULER_NO_TASK != s->listen_task)
-    {
-      GNUNET_SCHEDULER_cancel (s->listen_task);
-      s->listen_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (s->listen_task);
+    s->listen_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (s->listen_sockets != NULL)
-    {
-      i = 0;
-      while (s->listen_sockets[i] != NULL)
-        GNUNET_break (GNUNET_OK ==
-                      GNUNET_NETWORK_socket_close (s->listen_sockets[i++]));
-      GNUNET_free (s->listen_sockets);
-      s->listen_sockets = NULL;
-    }
+  {
+    i = 0;
+    while (s->listen_sockets[i] != NULL)
+      GNUNET_break (GNUNET_OK ==
+                    GNUNET_NETWORK_socket_close (s->listen_sockets[i++]));
+    GNUNET_free (s->listen_sockets);
+    s->listen_sockets = NULL;
+  }
   while (s->clients != NULL)
     GNUNET_SERVER_client_disconnect (s->clients);
   while (NULL != (hpos = s->handlers))
-    {
-      s->handlers = hpos->next;
-      GNUNET_free (hpos);
-    }
+  {
+    s->handlers = hpos->next;
+    GNUNET_free (hpos);
+  }
   while (NULL != (npos = s->disconnect_notify_list))
-    {
-      npos->callback (npos->callback_cls, NULL);
-      s->disconnect_notify_list = npos->next;
-      GNUNET_free (npos);
-    }
+  {
+    npos->callback (npos->callback_cls, NULL);
+    s->disconnect_notify_list = npos->next;
+    GNUNET_free (npos);
+  }
   GNUNET_free (s);
 }
 
@@ -595,8 +588,7 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s)
  */
 void
 GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle *server,
-                            const struct GNUNET_SERVER_MessageHandler
-                            *handlers)
+                            const struct GNUNET_SERVER_MessageHandler *handlers)
 {
   struct HandlerList *p;
 
@@ -614,19 +606,21 @@ GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle *server,
  * @param tc scheduler context (unused)
  */
 static void
-warn_no_receive_done (void *cls, 
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+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);
+                                                    &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);
+                _
+                ("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);
 }
 
 
@@ -641,10 +635,10 @@ void
 GNUNET_SERVER_disable_receive_done_warning (struct GNUNET_SERVER_Client *client)
 {
   if (GNUNET_SCHEDULER_NO_TASK != client->warn_task)
-    {
-      GNUNET_SCHEDULER_cancel (client->warn_task);
-      client->warn_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (client->warn_task);
+    client->warn_task = GNUNET_SCHEDULER_NO_TASK;
+  }
 }
 
 
@@ -686,53 +680,49 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
   pos = server->handlers;
   found = GNUNET_NO;
   while (pos != NULL)
+  {
+    i = 0;
+    while (pos->handlers[i].callback != NULL)
     {
-      i = 0;
-      while (pos->handlers[i].callback != NULL)
+      mh = &pos->handlers[i];
+      if ((mh->type == type) || (mh->type == GNUNET_MESSAGE_TYPE_ALL))
+      {
+        if ((mh->expected_size != 0) && (mh->expected_size != size))
         {
-          mh = &pos->handlers[i];
-          if ( (mh->type == type) ||
-               (mh->type == GNUNET_MESSAGE_TYPE_ALL) )
-            {
-              if ((mh->expected_size != 0) && (mh->expected_size != size))
-                {
 #if GNUNET8_NETWORK_IS_DEAD
-                  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                              "Expected %u bytes for message of type %u, got %u\n",
-                              mh->expected_size,
-                              mh->type,
-                              size);
-                  GNUNET_break_op (0);
+          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                      "Expected %u bytes for message of type %u, got %u\n",
+                      mh->expected_size, mh->type, size);
+          GNUNET_break_op (0);
 #endif
-                  return GNUNET_SYSERR;
-                }
-              if (sender != NULL)
-                {
-                  if (0 == sender->suspended)
-                    {
-                      sender->warn_start = GNUNET_TIME_absolute_get ();
-                      sender->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                                        &warn_no_receive_done,
-                                                                        sender);
-                      sender->warn_type = type;
-                    }
-                  sender->suspended++;
-                }
-              mh->callback (mh->callback_cls, sender, message);
-              found = GNUNET_YES;
-            }
-          i++;
+          return GNUNET_SYSERR;
         }
-      pos = pos->next;
+        if (sender != NULL)
+        {
+          if (0 == sender->suspended)
+          {
+            sender->warn_start = GNUNET_TIME_absolute_get ();
+            sender->warn_task =
+                GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                              &warn_no_receive_done, sender);
+            sender->warn_type = type;
+          }
+          sender->suspended++;
+        }
+        mh->callback (mh->callback_cls, sender, message);
+        found = GNUNET_YES;
+      }
+      i++;
     }
+    pos = pos->next;
+  }
   if (found == GNUNET_NO)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-                  "Received message of unknown type %d\n",
-                  type);
-      if (server->require_found == GNUNET_YES)
-        return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                "Received message of unknown type %d\n", type);
+    if (server->require_found == GNUNET_YES)
+      return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -751,8 +741,7 @@ static void
 process_incoming (void *cls,
                   const void *buf,
                   size_t available,
-                  const struct sockaddr *addr, 
-                  socklen_t addrlen, int errCode);
+                  const struct sockaddr *addr, socklen_t addrlen, int errCode);
 
 
 /**
@@ -769,51 +758,49 @@ process_incoming (void *cls,
  *            GNUNET_SYSERR if we should instantly abort due to error in a previous step
  */
 static void
-process_mst (struct GNUNET_SERVER_Client *client,
-             int ret)
+process_mst (struct GNUNET_SERVER_Client *client, int ret)
 {
-  while ( (ret != GNUNET_SYSERR) && 
-          (client->server != NULL) &&
-          (GNUNET_YES != client->shutdown_now) &&
-          (0 == client->suspended) )
+  while ((ret != GNUNET_SYSERR) &&
+         (client->server != NULL) &&
+         (GNUNET_YES != client->shutdown_now) && (0 == client->suspended))
+  {
+    if (ret == GNUNET_OK)
     {
-      if (ret == GNUNET_OK)
-        {
-          client->receive_pending = GNUNET_YES;
+      client->receive_pending = GNUNET_YES;
 #if DEBUG_SERVER
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Server re-enters receive loop, timeout: %llu.\n", client->idle_timeout.rel_value);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Server re-enters receive loop, timeout: %llu.\n",
+                  client->idle_timeout.rel_value);
 #endif
-          GNUNET_CONNECTION_receive (client->connection,
-                                     GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                                     client->idle_timeout,
-                                     &process_incoming, client);
-          break;
-        }
+      GNUNET_CONNECTION_receive (client->connection,
+                                 GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+                                 client->idle_timeout,
+                                 &process_incoming, client);
+      break;
+    }
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server processes additional messages instantly.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Server processes additional messages instantly.\n");
 #endif
-      ret = GNUNET_SERVER_mst_receive (client->mst, client, NULL, 0, GNUNET_NO, GNUNET_YES);
-    }
+    ret =
+        GNUNET_SERVER_mst_receive (client->mst, client, NULL, 0, GNUNET_NO,
+                                   GNUNET_YES);
+  }
 #if DEBUG_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Server leaves instant processing loop: ret = %d, server = %p, shutdown = %d, suspended = %u\n",
-              ret,
-              client->server,
-              client->shutdown_now,
-              client->suspended);
+              "Server leaves instant processing loop: ret = %d, server = %p, shutdown = %d, suspended = %u\n",
+              ret, client->server, client->shutdown_now, client->suspended);
 #endif
 
   if (ret == GNUNET_NO)
-    {
+  {
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Server has more data pending but is suspended.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Server has more data pending but is suspended.\n");
 #endif
-      client->receive_pending = GNUNET_SYSERR; /* data pending */
-    }
-  if ( (ret == GNUNET_SYSERR) ||
-       (GNUNET_YES == client->shutdown_now) )
+    client->receive_pending = GNUNET_SYSERR;    /* data pending */
+  }
+  if ((ret == GNUNET_SYSERR) || (GNUNET_YES == client->shutdown_now))
     GNUNET_SERVER_client_disconnect (client);
   GNUNET_SERVER_client_drop (client);
 }
@@ -833,8 +820,7 @@ static void
 process_incoming (void *cls,
                   const void *buf,
                   size_t available,
-                  const struct sockaddr *addr, 
-                  socklen_t addrlen, int errCode)
+                  const struct sockaddr *addr, socklen_t addrlen, int errCode)
 {
   struct GNUNET_SERVER_Client *client = cls;
   struct GNUNET_SERVER_Handle *server = client->server;
@@ -845,48 +831,48 @@ process_incoming (void *cls,
   GNUNET_assert (client->receive_pending == GNUNET_YES);
   client->receive_pending = GNUNET_NO;
   now = GNUNET_TIME_absolute_get ();
-  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) &&
-       (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
-       (end.abs_value > now.abs_value) )
-    {
-      /* wait longer, timeout changed (i.e. due to us sending) */
+  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) &&
+      (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
+      (end.abs_value > now.abs_value))
+  {
+    /* wait longer, timeout changed (i.e. due to us sending) */
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receive time out, but no disconnect due to sending (%p)\n",
-                  GNUNET_a2s (addr, addrlen));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receive time out, but no disconnect due to sending (%p)\n",
+                GNUNET_a2s (addr, addrlen));
 #endif
-      client->receive_pending = GNUNET_YES;
-      GNUNET_CONNECTION_receive (client->connection,
-                                 GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                                 GNUNET_TIME_absolute_get_remaining (end),
-                                 &process_incoming, client);
-      return;
-    }
+    client->receive_pending = GNUNET_YES;
+    GNUNET_CONNECTION_receive (client->connection,
+                               GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+                               GNUNET_TIME_absolute_get_remaining (end),
+                               &process_incoming, client);
+    return;
+  }
   if ((buf == NULL) ||
       (available == 0) ||
       (errCode != 0) ||
       (server == NULL) ||
       (client->shutdown_now == GNUNET_YES) ||
       (GNUNET_YES != GNUNET_CONNECTION_check (client->connection)))
-    {
-      /* other side closed connection, error connecting, etc. */
-      GNUNET_SERVER_client_disconnect (client);
-      return;
-    }
+  {
+    /* other side closed connection, error connecting, etc. */
+    GNUNET_SERVER_client_disconnect (client);
+    return;
+  }
 #if DEBUG_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Server receives %u bytes from `%s'.\n",
-              (unsigned int) available, 
-              GNUNET_a2s (addr, addrlen));
+              (unsigned int) available, GNUNET_a2s (addr, addrlen));
 #endif
   GNUNET_SERVER_client_keep (client);
   client->last_activity = now;
-  ret = GNUNET_SERVER_mst_receive (client->mst, client, buf, available, GNUNET_NO, GNUNET_YES);
+  ret =
+      GNUNET_SERVER_mst_receive (client->mst, client, buf, available, GNUNET_NO,
+                                 GNUNET_YES);
   process_mst (client, ret);
 }
 
@@ -899,34 +885,33 @@ process_incoming (void *cls,
  * @param tc scheduler context (unused)
  */
 static void
-restart_processing (void *cls, 
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_SERVER_Client *client = cls;
   struct GNUNET_SERVER_Handle *server = client->server;
 
   client->restart_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) &&
-       (GNUNET_NO == server->clients_ignore_shutdown) )
-    {
-      GNUNET_SERVER_client_disconnect (client);
-      return;
-    }  
+  if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) &&
+      (GNUNET_NO == server->clients_ignore_shutdown))
+  {
+    GNUNET_SERVER_client_disconnect (client);
+    return;
+  }
   if (client->receive_pending == GNUNET_NO)
-    {
+  {
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Server begins to read again from client.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Server begins to read again from client.\n");
 #endif
-      client->receive_pending = GNUNET_YES;
-      GNUNET_CONNECTION_receive (client->connection,
-                                 GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                                 client->idle_timeout, &process_incoming, client);
-      return;
-    }
+    client->receive_pending = GNUNET_YES;
+    GNUNET_CONNECTION_receive (client->connection,
+                               GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+                               client->idle_timeout, &process_incoming, client);
+    return;
+  }
 #if DEBUG_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Server continues processing messages still in the buffer.\n");
+              "Server continues processing messages still in the buffer.\n");
 #endif
   GNUNET_SERVER_client_keep (client);
   client->receive_pending = GNUNET_NO;
@@ -944,8 +929,8 @@ restart_processing (void *cls,
  */
 static void
 client_message_tokenizer_callback (void *cls,
-                                   void *client,
-                                   const struct GNUNET_MessageHeader *message)
+                                   void *client,
+                                   const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVER_Handle *server = cls;
   struct GNUNET_SERVER_Client *sender = client;
@@ -954,14 +939,14 @@ client_message_tokenizer_callback (void *cls,
 #if DEBUG_SERVER
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Tokenizer gives server message of type %u from client\n",
-              ntohs (message->type));
+              "Tokenizer gives server message of type %u from client\n",
+              ntohs (message->type));
 #endif
   sender->in_process_client_buffer = GNUNET_YES;
   ret = GNUNET_SERVER_inject (server, sender, message);
   sender->in_process_client_buffer = GNUNET_NO;
   if (GNUNET_OK != ret)
-    GNUNET_SERVER_client_disconnect (sender); 
+    GNUNET_SERVER_client_disconnect (sender);
 }
 
 
@@ -988,7 +973,7 @@ GNUNET_SERVER_connect_socket (struct
   client = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Client));
   client->connection = connection;
   client->mst = GNUNET_SERVER_mst_create (&client_message_tokenizer_callback,
-                                          server);
+                                          server);
   client->reference_count = 1;
   client->server = server;
   client->last_activity = GNUNET_TIME_absolute_get ();
@@ -999,8 +984,8 @@ GNUNET_SERVER_connect_socket (struct
   client->callback = NULL;
   client->callback_cls = NULL;
   GNUNET_CONNECTION_receive (client->connection,
-                             GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                             client->idle_timeout, &process_incoming, client);
+                             GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+                             client->idle_timeout, &process_incoming, client);
   return client;
 }
 
@@ -1014,8 +999,8 @@ GNUNET_SERVER_connect_socket (struct
  * @param timeout new timeout for activities on the socket
  */
 void
-GNUNET_SERVER_client_set_timeout(struct GNUNET_SERVER_Client *client,
-                                 struct GNUNET_TIME_Relative timeout)
+GNUNET_SERVER_client_set_timeout (struct GNUNET_SERVER_Client *client,
+                                  struct GNUNET_TIME_Relative timeout)
 {
   client->idle_timeout = timeout;
 }
@@ -1048,8 +1033,7 @@ GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client)
 {
   GNUNET_assert (client->reference_count > 0);
   client->reference_count--;
-  if ( (client->shutdown_now == GNUNET_YES) && 
-       (client->reference_count == 0) )
+  if ((client->shutdown_now == GNUNET_YES) && (client->reference_count == 0))
     GNUNET_SERVER_client_disconnect (client);
 }
 
@@ -1066,8 +1050,7 @@ int
 GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
                                   void **addr, size_t * addrlen)
 {
-  return GNUNET_CONNECTION_get_address (client->connection,
-                                        addr, addrlen);
+  return GNUNET_CONNECTION_get_address (client->connection, addr, addrlen);
 }
 
 
@@ -1105,8 +1088,8 @@ GNUNET_SERVER_disconnect_notify (struct GNUNET_SERVER_Handle *server,
  */
 void
 GNUNET_SERVER_disconnect_notify_cancel (struct GNUNET_SERVER_Handle *server,
-                                        GNUNET_SERVER_DisconnectCallback callback,
-                                        void *callback_cls)
+                                        GNUNET_SERVER_DisconnectCallback
+                                        callback, void *callback_cls)
 {
   struct NotifyList *pos;
   struct NotifyList *prev;
@@ -1114,18 +1097,17 @@ GNUNET_SERVER_disconnect_notify_cancel (struct GNUNET_SERVER_Handle *server,
   prev = NULL;
   pos = server->disconnect_notify_list;
   while (pos != NULL)
-    {
-      if ( (pos->callback == callback) &&
-           (pos->callback_cls == callback_cls ) )
-        break;
-      prev = pos;
-      pos = pos->next;
-    }
+  {
+    if ((pos->callback == callback) && (pos->callback_cls == callback_cls))
+      break;
+    prev = pos;
+    pos = pos->next;
+  }
   if (pos == NULL)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   if (prev == NULL)
     server->disconnect_notify_list = pos->next;
   else
@@ -1153,81 +1135,81 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
 
 #if DEBUG_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client is being disconnected from the server.\n");
+              "Client is being disconnected from the server.\n");
 #endif
   if (client->restart_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (client->restart_task);
+    client->restart_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (client->warn_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (client->warn_task);
+    client->warn_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (GNUNET_YES == client->receive_pending)
+  {
+    GNUNET_CONNECTION_receive_cancel (client->connection);
+    client->receive_pending = GNUNET_NO;
+  }
+
+  rc = client->reference_count;
+  if (client->server != NULL)
+  {
+    server = client->server;
+    client->server = NULL;
+    client->shutdown_now = GNUNET_YES;
+    prev = NULL;
+    pos = server->clients;
+    while ((pos != NULL) && (pos != client))
+    {
+      prev = pos;
+      pos = pos->next;
+    }
+    GNUNET_assert (pos != NULL);
+    if (prev == NULL)
+      server->clients = pos->next;
+    else
+      prev->next = pos->next;
+    if (client->restart_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_SCHEDULER_cancel (client->restart_task);
       client->restart_task = GNUNET_SCHEDULER_NO_TASK;
     }
-  if (client->warn_task != GNUNET_SCHEDULER_NO_TASK)
+    if (client->warn_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_SCHEDULER_cancel (client->warn_task);
       client->warn_task = GNUNET_SCHEDULER_NO_TASK;
     }
-  if (GNUNET_YES == client->receive_pending)
+    n = server->disconnect_notify_list;
+    while (n != NULL)
     {
-      GNUNET_CONNECTION_receive_cancel (client->connection);
-      client->receive_pending = GNUNET_NO;
-    }
-
-  rc = client->reference_count;  
-  if (client->server != NULL)
-    {
-      server = client->server;
-      client->server = NULL;
-      client->shutdown_now = GNUNET_YES;
-      prev = NULL;
-      pos = server->clients;
-      while ((pos != NULL) && (pos != client))
-        {
-          prev = pos;
-          pos = pos->next;
-        }
-      GNUNET_assert (pos != NULL);
-      if (prev == NULL)
-        server->clients = pos->next;
-      else
-        prev->next = pos->next;
-      if (client->restart_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (client->restart_task);
-          client->restart_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      if (client->warn_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (client->warn_task);
-          client->warn_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      n = server->disconnect_notify_list;
-      while (n != NULL)
-        {
-          n->callback (n->callback_cls, client);
-          n = n->next;
-        }
+      n->callback (n->callback_cls, client);
+      n = n->next;
     }
+  }
   if (rc > 0)
-    {
+  {
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "RC still positive, not destroying everything.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "RC still positive, not destroying everything.\n");
 #endif
-      return;
-    }
+    return;
+  }
   if (client->in_process_client_buffer == GNUNET_YES)
-    {
+  {
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Still processing inputs, not destroying everything.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Still processing inputs, not destroying everything.\n");
 #endif
-      return;
-    }
+    return;
+  }
 
   if (client->persist == GNUNET_YES)
-    GNUNET_CONNECTION_persist_ (client->connection);  
+    GNUNET_CONNECTION_persist_ (client->connection);
   GNUNET_CONNECTION_destroy (client->connection, GNUNET_NO);
   GNUNET_SERVER_mst_destroy (client->mst);
-  GNUNET_free (client);  
+  GNUNET_free (client);
 }
 
 
@@ -1255,7 +1237,7 @@ GNUNET_SERVER_client_disable_corking (struct GNUNET_SERVER_Client *client)
  * @param buf where to copy the message 
  * @return number of bytes actually transmitted
  */
-static size_t 
+static size_t
 transmit_ready_callback_wrapper (void *cls, size_t size, void *buf)
 {
   struct GNUNET_SERVER_Client *client = cls;
@@ -1263,7 +1245,7 @@ transmit_ready_callback_wrapper (void *cls, size_t size, void *buf)
 
   ret = client->callback (client->callback_cls, size, buf);
   if (ret > 0)
-    client->last_activity = GNUNET_TIME_absolute_get();
+    client->last_activity = GNUNET_TIME_absolute_get ();
   return ret;
 }
 
@@ -1293,9 +1275,10 @@ 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,
-                                                  timeout,
-                                                  &transmit_ready_callback_wrapper, client);
+                                                  size,
+                                                  timeout,
+                                                  &transmit_ready_callback_wrapper,
+                                                  client);
 }
 
 
@@ -1332,47 +1315,46 @@ GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success)
   GNUNET_assert (client->suspended > 0);
   client->suspended--;
   if (success != GNUNET_OK)
-    {
+  {
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "GNUNET_SERVER_receive_done called with failure indication\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "GNUNET_SERVER_receive_done called with failure indication\n");
 #endif
-      GNUNET_SERVER_client_disconnect (client);
-      return;
-    }
+    GNUNET_SERVER_client_disconnect (client);
+    return;
+  }
   if (client->suspended > 0)
-    {
+  {
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "GNUNET_SERVER_receive_done called, but more clients pending\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "GNUNET_SERVER_receive_done called, but more clients pending\n");
 #endif
-      return;
-    }
+    return;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != client->warn_task)
-    {
-      GNUNET_SCHEDULER_cancel (client->warn_task);
-      client->warn_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (client->warn_task);
+    client->warn_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (client->in_process_client_buffer == GNUNET_YES)
-    {
+  {
 #if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "GNUNET_SERVER_receive_done called while still in processing loop\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "GNUNET_SERVER_receive_done called while still in processing loop\n");
 #endif
-      return;
-    }
+    return;
+  }
   if (client->server == NULL)
-    {
-      GNUNET_SERVER_client_disconnect (client);
-      return;
-    }
+  {
+    GNUNET_SERVER_client_disconnect (client);
+    return;
+  }
 #if DEBUG_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
+              "GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
 #endif
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == client->restart_task);
-  client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing,
-                                                   client);
+  client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing, client);
 }