X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fserver.c;h=1a4b73126397f1c9d8c6076824fc014b1dce857c;hb=34f34474b6137233d6700d4599f42257e8208af2;hp=b2b590dbdba55be059aa9df38d887d74d76430a7;hpb=1aad2ce1a9604aa631d92fc7aebcd0def34736cc;p=oweals%2Fgnunet.git

diff --git a/src/util/server.c b/src/util/server.c
index b2b590dbd..1a4b73126 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2009-2013 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2009-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -122,12 +122,12 @@ struct GNUNET_SERVER_Handle
   /**
    * Function to call for access control.
    */
-  GNUNET_CONNECTION_AccessCheck access;
+  GNUNET_CONNECTION_AccessCheck access_cb;
 
   /**
-   * Closure for access.
+   * Closure for @e access_cb.
    */
-  void *access_cls;
+  void *access_cb_cls;
 
   /**
    * NULL-terminated array of sockets used to listen for new
@@ -144,7 +144,7 @@ struct GNUNET_SERVER_Handle
   /**
    * Task scheduled to do the listening.
    */
-  GNUNET_SCHEDULER_TaskIdentifier listen_task;
+  struct GNUNET_SCHEDULER_Task * listen_task;
 
   /**
    * Alternative function to create a MST instance.
@@ -246,12 +246,12 @@ struct GNUNET_SERVER_Client
   /**
    * ID of task used to restart processing.
    */
-  GNUNET_SCHEDULER_TaskIdentifier restart_task;
+  struct GNUNET_SCHEDULER_Task * restart_task;
 
   /**
    * Task that warns about missing calls to #GNUNET_SERVER_receive_done.
    */
-  GNUNET_SCHEDULER_TaskIdentifier warn_task;
+  struct GNUNET_SCHEDULER_Task * warn_task;
 
   /**
    * Time when the warn task was started.
@@ -397,35 +397,32 @@ process_listen_socket (void *cls,
 {
   struct GNUNET_SERVER_Handle *server = cls;
   struct GNUNET_CONNECTION_Handle *sock;
-  struct GNUNET_SERVER_Client *client;
   unsigned int i;
 
-  server->listen_task = GNUNET_SCHEDULER_NO_TASK;
+  server->listen_task = NULL;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
     /* ignore shutdown, someone else will take care of it! */
     GNUNET_SERVER_resume (server);
     return;
   }
-  i = 0;
-  while (NULL != server->listen_sockets[i])
+  for (i = 0; NULL != server->listen_sockets[i]; 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,
+          GNUNET_CONNECTION_create_from_accept (server->access_cb,
+                                                server->access_cb_cls,
                                                 server->listen_sockets[i]);
       if (NULL != sock)
       {
         LOG (GNUNET_ERROR_TYPE_DEBUG,
              "Server accepted incoming connection.\n");
-        client = GNUNET_SERVER_connect_socket (server, sock);
-        /* decrement reference count, we don't keep "client" alive */
-        GNUNET_SERVER_client_drop (client);
+        (void) GNUNET_SERVER_connect_socket (server,
+                                             sock);
       }
     }
-    i++;
   }
   /* listen for more! */
   GNUNET_SERVER_resume (server);
@@ -479,10 +476,13 @@ open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
        * 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");
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+                    "bind");
       if (0 != port)
-        LOG (GNUNET_ERROR_TYPE_ERROR, _("`%s' failed for port %d (%s).\n"),
-             "bind", port,
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("`%s' failed for port %d (%s).\n"),
+             "bind",
+             port,
              (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
       eno = 0;
     }
@@ -507,13 +507,15 @@ open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
   }
   if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
   {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "listen");
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+                  "listen");
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
     errno = 0;
     return NULL;
   }
   if (0 != port)
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Server starts to listen on port %u.\n",
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Server starts to listen on port %u.\n",
          port);
   return sock;
 }
@@ -522,8 +524,8 @@ open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
 /**
  * Create a new server.
  *
- * @param access function for access control
- * @param access_cls closure for access
+ * @param access_cb function for access control
+ * @param access_cb_cls closure for @a access_cb
  * @param lsocks NULL-terminated array of listen sockets
  * @param idle_timeout after how long should we timeout idle connections?
  * @param require_found if #GNUNET_YES, connections sending messages of unknown type
@@ -532,8 +534,8 @@ open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
  *         (typically, "port" already in use)
  */
 struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
-                                   void *access_cls,
+GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access_cb,
+                                   void *access_cb_cls,
                                    struct GNUNET_NETWORK_Handle **lsocks,
                                    struct GNUNET_TIME_Relative idle_timeout,
                                    int require_found)
@@ -543,8 +545,8 @@ GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
   server = GNUNET_new (struct GNUNET_SERVER_Handle);
   server->idle_timeout = idle_timeout;
   server->listen_sockets = lsocks;
-  server->access = access;
-  server->access_cls = access_cls;
+  server->access_cb = access_cb;
+  server->access_cb_cls = access_cb_cls;
   server->require_found = require_found;
   if (NULL != lsocks)
     GNUNET_SERVER_resume (server);
@@ -555,8 +557,8 @@ GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
 /**
  * Create a new server.
  *
- * @param access function for access control
- * @param access_cls closure for access
+ * @param access_cb function for access control
+ * @param access_cb_cls closure for @a access_cb
  * @param server_addr address to listen on (including port), NULL terminated array
  * @param socklen length of server_addr
  * @param idle_timeout after how long should we timeout idle connections?
@@ -566,7 +568,8 @@ GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
  *         (typically, "port" already in use)
  */
 struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
+GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access_cb,
+		      void *access_cb_cls,
                       struct sockaddr *const *server_addr,
                       const socklen_t * socklen,
                       struct GNUNET_TIME_Relative idle_timeout,
@@ -619,8 +622,11 @@ GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
   {
     lsocks = NULL;
   }
-  return GNUNET_SERVER_create_with_sockets (access, access_cls, lsocks,
-                                            idle_timeout, require_found);
+  return GNUNET_SERVER_create_with_sockets (access_cb,
+					    access_cb_cls,
+					    lsocks,
+                                            idle_timeout,
+					    require_found);
 }
 
 
@@ -691,10 +697,10 @@ test_monitor_clients (struct GNUNET_SERVER_Handle *server)
 void
 GNUNET_SERVER_suspend (struct GNUNET_SERVER_Handle *server)
 {
-  if (GNUNET_SCHEDULER_NO_TASK != server->listen_task)
+  if (NULL != server->listen_task)
   {
     GNUNET_SCHEDULER_cancel (server->listen_task);
-    server->listen_task = GNUNET_SCHEDULER_NO_TASK;
+    server->listen_task = NULL;
   }
 }
 
@@ -750,10 +756,10 @@ GNUNET_SERVER_stop_listening (struct GNUNET_SERVER_Handle *server)
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server in soft shutdown\n");
-  if (GNUNET_SCHEDULER_NO_TASK != server->listen_task)
+  if (NULL != server->listen_task)
   {
     GNUNET_SCHEDULER_cancel (server->listen_task);
-    server->listen_task = GNUNET_SCHEDULER_NO_TASK;
+    server->listen_task = NULL;
   }
   if (NULL != server->listen_sockets)
   {
@@ -784,10 +790,10 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server)
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server shutting down.\n");
-  if (GNUNET_SCHEDULER_NO_TASK != server->listen_task)
+  if (NULL != server->listen_task)
   {
     GNUNET_SCHEDULER_cancel (server->listen_task);
-    server->listen_task = GNUNET_SCHEDULER_NO_TASK;
+    server->listen_task = NULL;
   }
   if (NULL != server->listen_sockets)
   {
@@ -807,7 +813,8 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server)
   }
   while (NULL != (npos = server->disconnect_notify_list_head))
   {
-    npos->callback (npos->callback_cls, NULL);
+    npos->callback (npos->callback_cls,
+                    NULL);
     GNUNET_CONTAINER_DLL_remove (server->disconnect_notify_list_head,
 				 server->disconnect_notify_list_tail,
 				 npos);
@@ -815,7 +822,8 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server)
   }
   while (NULL != (npos = server->connect_notify_list_head))
   {
-    npos->callback (npos->callback_cls, NULL);
+    npos->callback (npos->callback_cls,
+                    NULL);
     GNUNET_CONTAINER_DLL_remove (server->connect_notify_list_head,
 				 server->connect_notify_list_tail,
 				 npos);
@@ -909,10 +917,10 @@ warn_no_receive_done (void *cls,
 void
 GNUNET_SERVER_disable_receive_done_warning (struct GNUNET_SERVER_Client *client)
 {
-  if (GNUNET_SCHEDULER_NO_TASK != client->warn_task)
+  if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
-    client->warn_task = GNUNET_SCHEDULER_NO_TASK;
+    client->warn_task = NULL;
   }
 }
 
@@ -975,7 +983,7 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
         if (NULL != sender)
         {
           if ( (0 == sender->suspended) &&
-	       (GNUNET_SCHEDULER_NO_TASK == sender->warn_task) )
+	       (NULL == sender->warn_task) )
           {
 	    GNUNET_break (0 != type); /* type should never be 0 here, as we don't use 0 */
             sender->warn_start = GNUNET_TIME_absolute_get ();
@@ -1036,7 +1044,8 @@ 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 ((GNUNET_SYSERR != ret) && (NULL != client->server) &&
          (GNUNET_YES != client->shutdown_now) && (0 == client->suspended))
@@ -1049,7 +1058,8 @@ process_mst (struct GNUNET_SERVER_Client *client, int ret)
       client->receive_pending = GNUNET_YES;
       GNUNET_CONNECTION_receive (client->connection,
                                  GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                                 client->idle_timeout, &process_incoming,
+                                 client->idle_timeout,
+                                 &process_incoming,
                                  client);
       break;
     }
@@ -1088,12 +1098,16 @@ process_mst (struct GNUNET_SERVER_Client *client, int ret)
  * @param buf buffer with data received from network
  * @param available number of bytes available in buf
  * @param addr address of the sender
- * @param addrlen length of addr
+ * @param addrlen length of @a addr
  * @param errCode code indicating errors receiving, 0 for success
  */
 static void
-process_incoming (void *cls, const void *buf, size_t available,
-                  const struct sockaddr *addr, socklen_t addrlen, int errCode)
+process_incoming (void *cls,
+                  const void *buf,
+                  size_t available,
+                  const struct sockaddr *addr,
+                  socklen_t addrlen,
+                  int errCode)
 {
   struct GNUNET_SERVER_Client *client = cls;
   struct GNUNET_SERVER_Handle *server = client->server;
@@ -1104,45 +1118,69 @@ process_incoming (void *cls, const void *buf, size_t available,
   GNUNET_assert (GNUNET_YES == client->receive_pending);
   client->receive_pending = GNUNET_NO;
   now = GNUNET_TIME_absolute_get ();
-  end = GNUNET_TIME_absolute_add (client->last_activity, client->idle_timeout);
-
-  if ((NULL == buf) && (0 == available) && (NULL == addr) && (0 == errCode) &&
-      (GNUNET_YES != client->shutdown_now) && (NULL != server) &&
-      (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
-      (end.abs_value_us > now.abs_value_us))
+  end = GNUNET_TIME_absolute_add (client->last_activity,
+                                  client->idle_timeout);
+
+  if ( (NULL == buf) &&
+       (0 == available) &&
+       (NULL == addr) &&
+       (0 == errCode) &&
+       (GNUNET_YES != client->shutdown_now) &&
+       (NULL != server) &&
+       (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
+       (end.abs_value_us > now.abs_value_us) )
   {
     /* wait longer, timeout changed (i.e. due to us sending) */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Receive time out, but no disconnect due to sending (%p)\n",
-         GNUNET_a2s (addr, addrlen));
+         client);
     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);
+                               &process_incoming,
+                               client);
     return;
   }
-  if ((NULL == buf) || (0 == available) || (0 != errCode) || (NULL == server) ||
-      (GNUNET_YES == client->shutdown_now) ||
-      (GNUNET_YES != GNUNET_CONNECTION_check (client->connection)))
+  if ( (NULL == buf) ||
+       (0 == available) ||
+       (0 != errCode) ||
+       (NULL == server) ||
+       (GNUNET_YES == client->shutdown_now) ||
+       (GNUNET_YES != GNUNET_CONNECTION_check (client->connection)) )
   {
     /* other side closed connection, error connecting, etc. */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Failed to connect or other side closed connection (%p)\n",
+         client);
     GNUNET_SERVER_client_disconnect (client);
     return;
   }
-  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));
   GNUNET_SERVER_client_keep (client);
   client->last_activity = now;
 
   if (NULL != server->mst_receive)
-    ret =
-        client->server->mst_receive (client->server->mst_cls, client->mst,
-                                     client, buf, available, GNUNET_NO, GNUNET_YES);
+  {
+    ret = client->server->mst_receive (client->server->mst_cls,
+                                       client->mst,
+                                       client,
+                                       buf,
+                                       available,
+                                       GNUNET_NO,
+                                       GNUNET_YES);
+  }
   else if (NULL != client->mst)
   {
     ret =
-        GNUNET_SERVER_mst_receive (client->mst, client, buf, available, GNUNET_NO,
+        GNUNET_SERVER_mst_receive (client->mst,
+                                   client,
+                                   buf,
+                                   available,
+                                   GNUNET_NO,
                                    GNUNET_YES);
   }
   else
@@ -1150,8 +1188,8 @@ process_incoming (void *cls, const void *buf, size_t available,
     GNUNET_break (0);
     return;
   }
-
-  process_mst (client, ret);
+  process_mst (client,
+               ret);
   GNUNET_SERVER_client_drop (client);
 }
 
@@ -1160,30 +1198,34 @@ process_incoming (void *cls, const void *buf, size_t available,
  * Task run to start again receiving from the network
  * and process requests.
  *
- * @param cls our 'struct GNUNET_SERVER_Client*' to process more requests from
+ * @param cls our `struct GNUNET_SERVER_Client *` to process more requests from
  * @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;
 
   GNUNET_assert (GNUNET_YES != client->shutdown_now);
-  client->restart_task = GNUNET_SCHEDULER_NO_TASK;
+  client->restart_task = NULL;
   if (GNUNET_NO == client->receive_pending)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "Server begins to read again from client.\n");
     client->receive_pending = GNUNET_YES;
     GNUNET_CONNECTION_receive (client->connection,
                                GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                               client->idle_timeout, &process_incoming, client);
+                               client->idle_timeout,
+                               &process_incoming,
+                               client);
     return;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server continues processing messages still in the buffer.\n");
   GNUNET_SERVER_client_keep (client);
   client->receive_pending = GNUNET_NO;
-  process_mst (client, GNUNET_NO);
+  process_mst (client,
+               GNUNET_NO);
   GNUNET_SERVER_client_drop (client);
 }
 
@@ -1193,13 +1235,14 @@ restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * received a complete message.
  *
  * @param cls closure (struct GNUNET_SERVER_Handle)
- * @param client identification of the client (struct GNUNET_SERVER_Client*)
+ * @param client identification of the client (`struct GNUNET_SERVER_Client *`)
  * @param message the actual message
  *
  * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
  */
 static int
-client_message_tokenizer_callback (void *cls, void *client,
+client_message_tokenizer_callback (void *cls,
+                                   void *client,
                                    const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVER_Handle *server = cls;
@@ -1230,8 +1273,7 @@ client_message_tokenizer_callback (void *cls, void *client,
  * @param server the server to use
  * @param connection the connection to manage (client must
  *        stop using this connection from now on)
- * @return the client handle (client should call
- *         "client_drop" on the return value eventually)
+ * @return the client handle
  */
 struct GNUNET_SERVER_Client *
 GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
@@ -1242,7 +1284,6 @@ GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
 
   client = GNUNET_new (struct GNUNET_SERVER_Client);
   client->connection = connection;
-  client->reference_count = 1;
   client->server = server;
   client->last_activity = GNUNET_TIME_absolute_get ();
   client->idle_timeout = server->idle_timeout;
@@ -1254,15 +1295,17 @@ GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
         server->mst_create (server->mst_cls, client);
   else
     client->mst =
-        GNUNET_SERVER_mst_create (&client_message_tokenizer_callback, server);
+        GNUNET_SERVER_mst_create (&client_message_tokenizer_callback,
+                                  server);
   GNUNET_assert (NULL != client->mst);
   for (n = server->connect_notify_list_head; NULL != n; n = n->next)
     n->callback (n->callback_cls, client);
-
   client->receive_pending = GNUNET_YES;
   GNUNET_CONNECTION_receive (client->connection,
                              GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                             client->idle_timeout, &process_incoming, client);
+                             client->idle_timeout,
+                             &process_incoming,
+                             client);
   return client;
 }
 
@@ -1376,6 +1419,7 @@ GNUNET_SERVER_connect_notify (struct GNUNET_SERVER_Handle *server,
 			      void *callback_cls)
 {
   struct NotifyList *n;
+  struct GNUNET_SERVER_Client *client;
 
   n = GNUNET_new (struct NotifyList);
   n->callback = callback;
@@ -1383,6 +1427,8 @@ GNUNET_SERVER_connect_notify (struct GNUNET_SERVER_Handle *server,
   GNUNET_CONTAINER_DLL_insert (server->connect_notify_list_head,
 			       server->connect_notify_list_tail,
 			       n);
+  for (client = server->clients_head; NULL != client; client = client->next)
+    callback (callback_cls, client);
 }
 
 
@@ -1395,8 +1441,8 @@ GNUNET_SERVER_connect_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;
 
@@ -1447,7 +1493,7 @@ GNUNET_SERVER_connect_notify_cancel (struct GNUNET_SERVER_Handle *server,
 /**
  * Destroy the connection that is passed in via @a cls.  Used
  * as calling #GNUNET_CONNECTION_destroy from within a function
- * that was itself called from within 'process_notify' of
+ * that was itself called from within process_notify() of
  * 'connection.c' is not allowed (see #2329).
  *
  * @param cls connection to destroy
@@ -1479,15 +1525,15 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Client is being disconnected from the server.\n");
-  if (GNUNET_SCHEDULER_NO_TASK != client->restart_task)
+  if (NULL != client->restart_task)
   {
     GNUNET_SCHEDULER_cancel (client->restart_task);
-    client->restart_task = GNUNET_SCHEDULER_NO_TASK;
+    client->restart_task = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != client->warn_task)
+  if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
-    client->warn_task = GNUNET_SCHEDULER_NO_TASK;
+    client->warn_task = NULL;
   }
   if (GNUNET_YES == client->receive_pending)
   {
@@ -1503,27 +1549,34 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
 				 server->clients_tail,
 				 client);
     if (NULL != server->mst_destroy)
-      server->mst_destroy (server->mst_cls, client->mst);
+      server->mst_destroy (server->mst_cls,
+                           client->mst);
     else
       GNUNET_SERVER_mst_destroy (client->mst);
     client->mst = NULL;
     for (n = server->disconnect_notify_list_head; NULL != n; n = n->next)
-      n->callback (n->callback_cls, client);
+      n->callback (n->callback_cls,
+                   client);
   }
   client->reference_count--;
   if (client->reference_count > 0)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "RC still positive, not destroying everything.\n");
+         "RC of %p still positive, not destroying everything.\n",
+         client);
     client->server = NULL;
     return;
   }
   if (GNUNET_YES == client->in_process_client_buffer)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Still processing inputs, not destroying everything.\n");
+         "Still processing inputs of %p, not destroying everything.\n",
+         client);
     return;
   }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "RC of %p now zero, destroying everything.\n",
+       client);
   if (GNUNET_YES == client->persist)
     GNUNET_CONNECTION_persist_ (client->connection);
   if (NULL != client->th.cth)
@@ -1532,10 +1585,10 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
 				   client->connection);
   /* need to cancel again, as it might have been re-added
      in the meantime (i.e. during callbacks) */
-  if (GNUNET_SCHEDULER_NO_TASK != client->warn_task)
+  if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
-    client->warn_task = GNUNET_SCHEDULER_NO_TASK;
+    client->warn_task = NULL;
   }
   if (GNUNET_YES == client->receive_pending)
   {
@@ -1568,7 +1621,7 @@ GNUNET_SERVER_client_disable_corking (struct GNUNET_SERVER_Client *client)
  * Wrapper for transmission notification that calls the original
  * callback and update the last activity time for our connection.
  *
- * @param cls the `struct GNUNET_SERVER_Client`
+ * @param cls the `struct GNUNET_SERVER_Client *`
  * @param size number of bytes we can transmit
  * @param buf where to copy the message
  * @return number of bytes actually transmitted
@@ -1606,8 +1659,8 @@ struct GNUNET_SERVER_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)
+                                     GNUNET_CONNECTION_TransmitReadyNotify callback,
+                                     void *callback_cls)
 {
   if (NULL != client->th.callback)
     return NULL;
@@ -1684,10 +1737,10 @@ GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client,
          "GNUNET_SERVER_receive_done called, but more clients pending\n");
     return;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != client->warn_task)
+  if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
-    client->warn_task = GNUNET_SCHEDULER_NO_TASK;
+    client->warn_task = NULL;
   }
   if (GNUNET_YES == client->in_process_client_buffer)
   {
@@ -1702,8 +1755,9 @@ GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client,
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == client->restart_task);
-  client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing, client);
+  GNUNET_assert (NULL == client->restart_task);
+  client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing,
+                                                   client);
 }