1 files changed, 416 insertions, 400 deletions

diff --git a/src/util/server.c b/src/util/server.c
index 63993ee37..f792e5a67 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -33,6 +33,12 @@
 #include "gnunet_disk_lib.h"
 #include "gnunet_protocols.h"
 
+#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
+
+#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
+
 #define DEBUG_SERVER GNUNET_EXTRA_LOGGING
 
 /**
@@ -258,7 +264,8 @@ 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;
@@ -272,46 +279,47 @@ process_listen_socket (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   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]))
     {
-      sock =
-          GNUNET_CONNECTION_create_from_accept (server->access,
-                                                server->access_cls,
-                                                server->listen_sockets[i]);
-      if (sock != NULL)
-      {
+      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)
+            {
 #if DEBUG_SERVER
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Server accepted incoming connection.\n");
+              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);
-      }
+              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++;
     }
-    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);
+    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);
 }
 
@@ -332,87 +340,87 @@ 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;
-  }
+    {
+      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");
+    {
+      if (GNUNET_NETWORK_socket_setsockopt
+          (sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
+        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))
+        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)
     {
-      /* 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;
+      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' */
+          LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind");
+          if (port != 0)
+            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)
+            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)
+            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;
     }
-    else
+  if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
     {
-      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);
-
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "listen");
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
+      errno = 0;
+      return NULL;
     }
-    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,
-                "Server starts to listen on port %u.\n", port);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Server starts to listen on port %u.\n", port);
 #endif
   return sock;
 }
@@ -432,10 +440,10 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
  */
 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)
+                                   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;
@@ -448,18 +456,18 @@ GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
   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;
 }
 
@@ -479,10 +487,10 @@ GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
  */
 struct GNUNET_SERVER_Handle *
 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 sockaddr *const *serverAddr,
+                      const socklen_t * socklen,
+                      struct GNUNET_TIME_Relative idle_timeout,
+                      int require_found)
 {
   struct GNUNET_NETWORK_Handle **lsocks;
   unsigned int i;
@@ -492,31 +500,32 @@ GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
   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[j] = open_listen_socket (serverAddr[i], socklen[i]);
-      if (lsocks[j] != NULL)
-        j++;
-      i++;
+      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)
+            LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind");
+          GNUNET_free (lsocks);
+          lsocks = NULL;
+        }
     }
-    if (j == 0)
+  else
     {
-      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);
+                                            idle_timeout, require_found);
 }
 
 
@@ -533,35 +542,35 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s)
   unsigned int i;
 
 #if DEBUG_SERVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server shutting down.\n");
+  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);
 }
 
@@ -581,7 +590,8 @@ 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;
 
@@ -599,21 +609,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);
+    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);
+    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);
 }
 
 
@@ -625,13 +635,14 @@ warn_no_receive_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param client client for which to disable the warning
  */
 void
-GNUNET_SERVER_disable_receive_done_warning (struct GNUNET_SERVER_Client *client)
+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;
+    }
 }
 
 
@@ -652,8 +663,8 @@ GNUNET_SERVER_disable_receive_done_warning (struct GNUNET_SERVER_Client *client)
  */
 int
 GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
-                      struct GNUNET_SERVER_Client *sender,
-                      const struct GNUNET_MessageHeader *message)
+                      struct GNUNET_SERVER_Client *sender,
+                      const struct GNUNET_MessageHeader *message)
 {
   struct HandlerList *pos;
   const struct GNUNET_SERVER_MessageHandler *mh;
@@ -666,56 +677,57 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
   size = ntohs (message->size);
 #if DEBUG_SERVER
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Server schedules transmission of %u-byte message of type %u to client.\n",
-              size, type);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Server schedules transmission of %u-byte message of type %u to client.\n",
+       size, type);
 #endif
   pos = server->handlers;
   found = GNUNET_NO;
   while (pos != 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))
-        {
+      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))
+                {
 #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);
+                  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;
+                }
+              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;
     }
-    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;
-  }
+    {
+      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;
 }
 
@@ -732,7 +744,8 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
  */
 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);
 
 
 /**
@@ -752,44 +765,44 @@ static void
 process_mst (struct GNUNET_SERVER_Client *client, int ret)
 {
   while ((ret != GNUNET_SYSERR) && (client->server != NULL) &&
-         (GNUNET_YES != client->shutdown_now) && (0 == client->suspended))
-  {
-    if (ret == GNUNET_OK)
+         (GNUNET_YES != client->shutdown_now) && (0 == client->suspended))
     {
-      client->receive_pending = GNUNET_YES;
+      if (ret == GNUNET_OK)
+        {
+          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);
+          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");
+      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);
+  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);
 #endif
 
   if (ret == GNUNET_NO)
-  {
+    {
 #if DEBUG_SERVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Server has more data pending but is suspended.\n");
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Server has more data pending but is suspended.\n");
 #endif
-    client->receive_pending = GNUNET_SYSERR;    /* data pending */
-  }
+      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);
@@ -808,7 +821,7 @@ process_mst (struct GNUNET_SERVER_Client *client, int ret)
  */
 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;
@@ -819,43 +832,44 @@ process_incoming (void *cls, const void *buf, size_t available,
   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);
+  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) */
+    {
+      /* 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));
+      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;
-  }
-  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;
-  }
+      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;
+    }
 #if DEBUG_SERVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server receives %u bytes from `%s'.\n",
-              (unsigned int) available, GNUNET_a2s (addr, addrlen));
+  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);
   client->last_activity = now;
   ret =
-      GNUNET_SERVER_mst_receive (client->mst, client, buf, available, GNUNET_NO,
-                                 GNUNET_YES);
+    GNUNET_SERVER_mst_receive (client->mst, client, buf, available, GNUNET_NO,
+                               GNUNET_YES);
   process_mst (client, ret);
 }
 
@@ -876,25 +890,26 @@ restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   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;
-  }
+    {
+      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");
+      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");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Server continues processing messages still in the buffer.\n");
 #endif
   GNUNET_SERVER_client_keep (client);
   client->receive_pending = GNUNET_NO;
@@ -912,7 +927,7 @@ restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 static void
 client_message_tokenizer_callback (void *cls, void *client,
-                                   const struct GNUNET_MessageHeader *message)
+                                   const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVER_Handle *server = cls;
   struct GNUNET_SERVER_Client *sender = client;
@@ -920,9 +935,9 @@ client_message_tokenizer_callback (void *cls, void *client,
 
 #if DEBUG_SERVER
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Tokenizer gives server message of type %u from client\n",
-              ntohs (message->type));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "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);
@@ -946,14 +961,14 @@ client_message_tokenizer_callback (void *cls, void *client,
  */
 struct GNUNET_SERVER_Client *
 GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
-                              struct GNUNET_CONNECTION_Handle *connection)
+                              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);
+    GNUNET_SERVER_mst_create (&client_message_tokenizer_callback, server);
   client->reference_count = 1;
   client->server = server;
   client->last_activity = GNUNET_TIME_absolute_get ();
@@ -964,8 +979,8 @@ GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
   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;
 }
 
@@ -980,7 +995,7 @@ GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
  */
 void
 GNUNET_SERVER_client_set_timeout (struct GNUNET_SERVER_Client *client,
-                                  struct GNUNET_TIME_Relative timeout)
+                                  struct GNUNET_TIME_Relative timeout)
 {
   client->idle_timeout = timeout;
 }
@@ -1028,7 +1043,7 @@ GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client)
  */
 int
 GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
-                                  void **addr, size_t * addrlen)
+                                  void **addr, size_t * addrlen)
 {
   return GNUNET_CONNECTION_get_address (client->connection, addr, addrlen);
 }
@@ -1046,8 +1061,8 @@ GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
  */
 void
 GNUNET_SERVER_disconnect_notify (struct GNUNET_SERVER_Handle *server,
-                                 GNUNET_SERVER_DisconnectCallback callback,
-                                 void *callback_cls)
+                                 GNUNET_SERVER_DisconnectCallback callback,
+                                 void *callback_cls)
 {
   struct NotifyList *n;
 
@@ -1068,8 +1083,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;
@@ -1077,17 +1092,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
@@ -1114,76 +1129,76 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
   unsigned int rc;
 
 #if DEBUG_SERVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client is being disconnected from the server.\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "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;
     }
-    n = server->disconnect_notify_list;
-    while (n != NULL)
+  if (GNUNET_YES == client->receive_pending)
     {
-      n->callback (n->callback_cls, client);
-      n = n->next;
+      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;
+        }
     }
-  }
   if (rc > 0)
-  {
+    {
 #if DEBUG_SERVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "RC still positive, not destroying everything.\n");
+      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");
+      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);
@@ -1247,17 +1262,17 @@ transmit_ready_callback_wrapper (void *cls, size_t size, void *buf)
  */
 struct GNUNET_CONNECTION_TransmitHandle *
 GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
-                                     size_t size,
-                                     struct GNUNET_TIME_Relative timeout,
-                                     GNUNET_CONNECTION_TransmitReadyNotify
-                                     callback, void *callback_cls)
+                                     size_t size,
+                                     struct GNUNET_TIME_Relative timeout,
+                                     GNUNET_CONNECTION_TransmitReadyNotify
+                                     callback, void *callback_cls)
 {
   client->callback_cls = callback_cls;
   client->callback = callback;
   return GNUNET_CONNECTION_notify_transmit_ready (client->connection, size,
-                                                  timeout,
-                                                  &transmit_ready_callback_wrapper,
-                                                  client);
+                                                  timeout,
+                                                  &transmit_ready_callback_wrapper,
+                                                  client);
 }
 
 
@@ -1294,46 +1309,47 @@ 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");
+      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");
+      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");
+      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");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "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);
 }