X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fserver.c;h=606d4436906572167ecda4f2af35b6625b18073a;hb=555214089c7045298f23fea9e060ea931804e75f;hp=8d880b26f486caef46d13b2902e1cf10f91538a5;hpb=c3d2019f61f5010b42aa3c0ebb121f1fbfd91e0c;p=oweals%2Fgnunet.git

diff --git a/src/util/server.c b/src/util/server.c
index 8d880b26f..606d44369 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -22,9 +22,6 @@
  * @file util/server.c
  * @brief library for building GNUnet network servers
  * @author Christian Grothoff
- *
- * TODO:
- * - fix inefficient memmove in message processing
  */
 
 #include "platform.h"
@@ -157,15 +154,14 @@ struct GNUNET_SERVER_Client
 {
 
   /**
-   * Size of the buffer for incoming data.  Should be
-   * first so we get nice alignment.
+   * This is a linked list.
    */
-  char incoming_buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE];
+  struct GNUNET_SERVER_Client *next;
 
   /**
-   * This is a linked list.
+   * Processing of incoming data.
    */
-  struct GNUNET_SERVER_Client *next;
+  struct GNUNET_SERVER_MessageStreamTokenizer *mst;
 
   /**
    * Server that this client belongs to.
@@ -175,66 +171,19 @@ struct GNUNET_SERVER_Client
   /**
    * Client closure for callbacks.
    */
-  void *client_closure;
-
-  /**
-   * Callback to receive from client.
-   */
-  GNUNET_SERVER_ReceiveCallback receive;
-
-  /**
-   * Callback to cancel receive from client.
-   */
-  GNUNET_SERVER_ReceiveCancelCallback receive_cancel;
-
-  /**
-   * Callback to ask about transmit-ready notification.
-   */
-  GNUNET_SERVER_TransmitReadyCallback notify_transmit_ready;
-
-  /**
-   * Callback to ask about transmit-ready notification.
-   */
-  GNUNET_SERVER_TransmitReadyCancelCallback notify_transmit_ready_cancel;
-
-  /**
-   * Callback to check if client is still valid.
-   */
-  GNUNET_SERVER_CheckCallback check;
-
-  /**
-   * Callback to destroy client.
-   */
-  GNUNET_SERVER_DestroyCallback destroy;
-
-  /**
-   * Side-buffer for incoming data used when processing
-   * is suspended.
-   */
-  char *side_buf;
+  struct GNUNET_CONNECTION_Handle *connection;
 
   /**
    * ID of task used to restart processing.
    */
   GNUNET_SCHEDULER_TaskIdentifier restart_task;
 
-  /**
-   * Number of bytes in the side buffer.
-   */
-  size_t side_buf_size;
-
   /**
    * Last activity on this socket (used to time it out
    * if reference_count == 0).
    */
   struct GNUNET_TIME_Absolute last_activity;
 
-  /**
-   * How many bytes in the "incoming_buffer" are currently
-   * valid? (starting at offset 0).
-   */
-  size_t receive_pos;
-
   /**
    * Number of external entities with a reference to
    * this client object.
@@ -266,7 +215,8 @@ struct GNUNET_SERVER_Client
   int shutdown_now;
 
   /**
-   * Are we currently trying to receive?
+   * Are we currently trying to receive? (YES if we are, NO if we are not,
+   * SYSERR if data is already available in MST).
    */
   int receive_pending;
 
@@ -439,6 +389,60 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
 }
 
 
+/**
+ * Create a new server.
+ *
+ * @param sched scheduler to use
+ * @param access function for access control
+ * @param access_cls closure for access
+ * @param lsocks NULL-terminated array of listen sockets
+ * @param maxbuf maximum write buffer size for accepted sockets
+ * @param idle_timeout after how long should we timeout idle connections?
+ * @param require_found if YES, connections sending messages of unknown type
+ *        will be closed
+ * @return handle for the new server, NULL on error
+ *         (typically, "port" already in use)
+ */
+struct GNUNET_SERVER_Handle *
+GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
+				   GNUNET_CONNECTION_AccessCheck access, void *access_cls,
+				   struct GNUNET_NETWORK_Handle **lsocks,
+				   size_t maxbuf,
+				   struct GNUNET_TIME_Relative
+				   idle_timeout,
+				   int require_found)
+{
+  struct GNUNET_SERVER_Handle *ret;
+  struct GNUNET_NETWORK_FDSet *r;
+  int i;
+
+  ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Handle));
+  ret->sched = sched;
+  ret->maxbuf = maxbuf;
+  ret->idle_timeout = idle_timeout;
+  ret->listen_sockets = lsocks;
+  ret->access = 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 (sched,
+                                                      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;
+}
+
+
 /**
  * Create a new server.
  *
@@ -464,9 +468,7 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
                       struct GNUNET_TIME_Relative
                       idle_timeout, int require_found)
 {
-  struct GNUNET_SERVER_Handle *ret;
   struct GNUNET_NETWORK_Handle **lsocks;
-  struct GNUNET_NETWORK_FDSet *r;
   unsigned int i;
   unsigned int j;
 
@@ -498,30 +500,12 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
     {
       lsocks = NULL;
     }
-  ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Handle));
-  ret->sched = sched;
-  ret->maxbuf = maxbuf;
-  ret->idle_timeout = idle_timeout;
-  ret->listen_sockets = lsocks;
-  ret->access = 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 (sched,
-                                                      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;
+  return GNUNET_SERVER_create_with_sockets (sched,
+					    access, access_cls,
+					    lsocks,
+					    maxbuf, 
+					    idle_timeout,
+					    require_found);
 }
 
 
@@ -660,7 +644,8 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
   if (found == GNUNET_NO)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-                  _("Received message of unknown type %d\n"), type);
+                  "Received message of unknown type %d\n",
+		  type);
       if (server->require_found == GNUNET_YES)
         return GNUNET_SYSERR;
     }
@@ -669,64 +654,84 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
 
 
 /**
- * Go over the contents of the client buffer; as long as full messages
- * are available, pass them on for processing.  Update the buffer
- * accordingly.  Handles fatal errors by shutting down the connection.
+ * We are receiving an incoming message.  Process it.
  *
- * @param client identifies which client receive buffer to process
+ * @param cls our closure (handle for the client)
+ * @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 errCode code indicating errors receiving, 0 for success
  */
 static void
-process_client_buffer (struct GNUNET_SERVER_Client *client)
-{
-  struct GNUNET_SERVER_Handle *server;
-  const struct GNUNET_MessageHeader *hdr;
-  size_t msize;
+process_incoming (void *cls,
+                  const void *buf,
+                  size_t available,
+                  const struct sockaddr *addr, 
+		  socklen_t addrlen, int errCode);
 
-  client->in_process_client_buffer = GNUNET_YES;
-  server = client->server;
+
+/**
+ * Process messages from the client's message tokenizer until either
+ * the tokenizer is empty (and then schedule receiving more), or 
+ * until some handler is not immediately done (then wait for restart_processing)
+ * or shutdown.
+ *
+ * @param client the client to process, RC must have already been increased
+ *        using GNUNET_SERVER_client_keep and will be decreased by one in this
+ *        function
+ * @param ret GNUNET_NO to start processing from the buffer,
+ *            GNUNET_OK if the mst buffer is drained and we should instantly go back to receiving
+ *            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)
+{
+  while ( (ret != GNUNET_SYSERR) && 
+	  (client->server != NULL) &&
+	  (GNUNET_YES != client->shutdown_now) &&
+	  (0 == client->suspended) )
+    {
+      if (ret == GNUNET_OK)
+	{
+	  client->receive_pending = GNUNET_YES;
 #if DEBUG_SERVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Private buffer contains %u bytes; client is %s and we are %s\n",
-              client->receive_pos,
-              client->suspended ? "suspended" : "up",
-              client->shutdown_now ? "in shutdown" : "running");
+	  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		      "Server re-enters receive loop.\n");
 #endif
-  while ( (client->receive_pos >= sizeof (struct GNUNET_MessageHeader)) &&
-	  (0 == client->suspended) && 
-	  (GNUNET_YES != client->shutdown_now) )
-    {
-      hdr = (const struct GNUNET_MessageHeader *) &client->incoming_buffer;
-      msize = ntohs (hdr->size);
-      if (msize > client->receive_pos)
-        {
+	  GNUNET_CONNECTION_receive (client->connection,
+				     GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+				     client->server->idle_timeout, 
+				     &process_incoming, client);
+	  break;
+	}
 #if DEBUG_SERVER
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Total message size is %u, we only have %u bytes; need more data\n",
-                      msize, client->receive_pos);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server processes additional messages instantly.\n");
 #endif
-          break;
-        }
+      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);
+#endif
+
+  if (ret == GNUNET_NO)
+    {
 #if DEBUG_SERVER
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Passing %u bytes to callback for processing\n", msize);
+		  "Server has more data pending but is suspended.\n");
 #endif
-      if ( (msize < sizeof (struct GNUNET_MessageHeader)) ||
-	   (GNUNET_OK != GNUNET_SERVER_inject (server, client, hdr)) )
-        {
-          client->in_process_client_buffer = GNUNET_NO;
-          GNUNET_SERVER_client_disconnect (client);
-          return;
-        }
-      /* FIXME: this is highly inefficient; we should
-         try to avoid this if the new base address is
-         already nicely aligned.  See old handler code... */
-      memmove (client->incoming_buffer,
-               &client->incoming_buffer[msize], client->receive_pos - msize);
-      client->receive_pos -= msize;
+      client->receive_pending = GNUNET_SYSERR; /* data pending */
     }
-  client->in_process_client_buffer = GNUNET_NO;
-  if (GNUNET_YES == client->shutdown_now)
+  if ( (ret == GNUNET_SYSERR) ||
+       (GNUNET_YES == client->shutdown_now) )
     GNUNET_SERVER_client_disconnect (client);
+  GNUNET_SERVER_client_drop (client);
 }
 
 
@@ -744,20 +749,21 @@ 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;
-  const char *cbuf = buf;
-  size_t maxcpy;
+  int ret;
 
+  GNUNET_assert (client->receive_pending == GNUNET_YES);
   client->receive_pending = GNUNET_NO;
   if ((buf == NULL) ||
       (available == 0) ||
       (errCode != 0) ||
       (server == NULL) ||
       (client->shutdown_now == GNUNET_YES) ||
-      (GNUNET_YES != client->check (client->client_closure)))
+      (GNUNET_YES != GNUNET_CONNECTION_check (client->connection)))
     {
       /* other side closed connection, error connecting, etc. */
       GNUNET_SERVER_client_disconnect (client);
@@ -766,61 +772,13 @@ process_incoming (void *cls,
 #if DEBUG_SERVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Server receives %u bytes from `%s'.\n",
-              available, GNUNET_a2s (addr, addrlen));
+              (unsigned int) available, 
+	      GNUNET_a2s (addr, addrlen));
 #endif
   GNUNET_SERVER_client_keep (client);
   client->last_activity = GNUNET_TIME_absolute_get ();
-  /* process data (if available) */
-  while (available > 0)
-    {
-      maxcpy = available;
-      if (maxcpy > sizeof (client->incoming_buffer) - client->receive_pos)
-        maxcpy = sizeof (client->incoming_buffer) - client->receive_pos;
-#if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Can copy %u bytes to private buffer\n", maxcpy);
-#endif
-      memcpy (&client->incoming_buffer[client->receive_pos], cbuf, maxcpy);
-      client->receive_pos += maxcpy;
-      cbuf += maxcpy;
-      available -= maxcpy;
-      if (0 < client->suspended)
-        {
-          if (available > 0)
-            {
-#if DEBUG_SERVER
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Client has suspended processing; copying %u bytes to side buffer to be used later.\n",
-                          available);
-#endif
-              GNUNET_assert (client->side_buf_size == 0);
-              GNUNET_assert (client->side_buf == NULL);
-              client->side_buf_size = available;
-              client->side_buf = GNUNET_malloc (available);
-              memcpy (client->side_buf, cbuf, available);
-              available = 0;
-            }
-          break;                /* do not run next client iteration! */
-        }
-#if DEBUG_SERVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Now processing messages in private buffer\n");
-#endif
-      process_client_buffer (client);
-    }
-  GNUNET_assert (available == 0);
-  if ((client->suspended == 0) &&
-      (GNUNET_YES != client->shutdown_now) && (client->server != NULL))
-    {
-      /* Finally, keep receiving! */
-      client->receive_pending = GNUNET_YES;
-      client->receive (client->client_closure,
-                       GNUNET_SERVER_MAX_MESSAGE_SIZE,
-                       server->idle_timeout, &process_incoming, client);
-    }
-  if (GNUNET_YES == client->shutdown_now)
-    GNUNET_SERVER_client_disconnect (client);
-  GNUNET_SERVER_client_drop (client);
+  ret = GNUNET_SERVER_mst_receive (client->mst, client, buf, available, GNUNET_NO, GNUNET_YES);
+  process_mst (client, ret);
 }
 
 
@@ -832,7 +790,8 @@ 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;
@@ -843,121 +802,56 @@ restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     {
       GNUNET_SERVER_client_disconnect (client);
       return;
-    }
-  GNUNET_SERVER_client_keep (client);
-  process_client_buffer (client);
-  if (0 == client->suspended)
+    }  
+  if (client->receive_pending == GNUNET_NO)
     {
+#if DEBUG_SERVER
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		  "Server begins to read again from client.\n");
+#endif
       client->receive_pending = GNUNET_YES;
-      client->receive (client->client_closure,
-		       GNUNET_SERVER_MAX_MESSAGE_SIZE,
-		       client->server->idle_timeout, &process_incoming, client);
+      GNUNET_CONNECTION_receive (client->connection,
+				 GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+				 client->server->idle_timeout, &process_incoming, client);
+      return;
     }
-  GNUNET_SERVER_client_drop (client);
-}
-
-
-/**
- * Add a client to the set of our clients and
- * start receiving.
- */
-static void
-add_client (struct GNUNET_SERVER_Handle *server,
-            struct GNUNET_SERVER_Client *client)
-{
-  client->server = server;
-  client->last_activity = GNUNET_TIME_absolute_get ();
-  client->next = server->clients;
-  server->clients = client;
-  client->receive_pending = GNUNET_YES;
-  client->receive (client->client_closure,
-                   GNUNET_SERVER_MAX_MESSAGE_SIZE,
-                   server->idle_timeout, &process_incoming, client);
+#if DEBUG_SERVER
+  GNUNET_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;
+  process_mst (client, GNUNET_NO);
 }
 
 
 /**
- * Create a request for receiving data from a socket.
+ * This function is called whenever our inbound message tokenizer has
+ * received a complete message.
  *
- * @param cls identifies the socket to receive from
- * @param max how much data to read at most
- * @param timeout when should this operation time out
- * @param receiver function to call for processing
- * @param receiver_cls closure for receiver
+ * @param cls closure (struct GNUNET_SERVER_Handle)
+ * @param client identification of the client (struct GNUNET_SERVER_Client*)
+ * @param message the actual message
  */
 static void
-sock_receive (void *cls,
-              size_t max,
-              struct GNUNET_TIME_Relative timeout,
-              GNUNET_CONNECTION_Receiver receiver, void *receiver_cls)
+client_message_tokenizer_callback (void *cls,
+				   void *client,
+				   const struct GNUNET_MessageHeader *message)
 {
-  GNUNET_CONNECTION_receive (cls, max, timeout, receiver, receiver_cls);
-}
-
-
-/**
- * Wrapper to cancel receiving from a socket.
- * 
- * @param cls handle to the GNUNET_CONNECTION_Handle to cancel
- */
-static void
-sock_receive_cancel (void *cls)
-{
-  GNUNET_CONNECTION_receive_cancel (cls);
-}
-
-
-/**
- * FIXME: document.
- */
-static void *
-sock_notify_transmit_ready (void *cls,
-                            size_t size,
-                            struct GNUNET_TIME_Relative timeout,
-                            GNUNET_CONNECTION_TransmitReadyNotify notify,
-                            void *notify_cls)
-{
-  return GNUNET_CONNECTION_notify_transmit_ready (cls, size, timeout, notify,
-                                                  notify_cls);
-}
-
-
-/**
- * FIXME: document.
- */
-static void
-sock_notify_transmit_ready_cancel (void *cls, void *h)
-{
-  GNUNET_CONNECTION_notify_transmit_ready_cancel (h);
-}
-
-
-/**
- * Check if socket is still valid (no fatal errors have happened so far).
- *
- * @param cls the socket
- * @return GNUNET_YES if valid, GNUNET_NO otherwise
- */
-static int
-sock_check (void *cls)
-{
-  return GNUNET_CONNECTION_check (cls);
-}
-
+  struct GNUNET_SERVER_Handle *server = cls;
+  struct GNUNET_SERVER_Client *sender = client;
+  int ret;
 
-/**
- * Destroy this socket (free resources).
- *
- * @param cls the socket
- * @param persist set the socket to be persisted
- */
-static void
-sock_destroy (void *cls, int persist)
-{
-  struct GNUNET_CONNECTION_Handle *sock = cls;
-  if (persist == GNUNET_YES)
-    GNUNET_CONNECTION_persist_ (sock);  
-  GNUNET_CONNECTION_destroy (sock, GNUNET_NO);
+#if DEBUG_SERVER
+  GNUNET_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);
+  sender->in_process_client_buffer = GNUNET_NO;
+  if (GNUNET_OK != ret)
+    GNUNET_SERVER_client_disconnect (sender); 
 }
 
 
@@ -982,65 +876,19 @@ GNUNET_SERVER_connect_socket (struct
   struct GNUNET_SERVER_Client *client;
 
   client = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Client));
-  client->client_closure = connection;
-  client->receive = &sock_receive;
-  client->receive_cancel = &sock_receive_cancel;
-  client->notify_transmit_ready = &sock_notify_transmit_ready;
-  client->notify_transmit_ready_cancel = &sock_notify_transmit_ready_cancel;
-  client->check = &sock_check;
-  client->destroy = &sock_destroy;
+  client->connection = connection;
+  client->mst = GNUNET_SERVER_mst_create (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+					  &client_message_tokenizer_callback,
+					  server);
   client->reference_count = 1;
-  add_client (server, client);
-  return client;
-}
-
-
-/**
- * Add an arbitrary connection to the set of handles managed by this
- * server.  This can be used if a sending and receiving does not
- * really go over the network (internal transmission) or for servers
- * using UDP.
- *
- * @param server the server to use
- * @param chandle opaque handle for the connection
- * @param creceive receive function for the connection
- * @param ccancel cancel receive function for the connection
- * @param cnotify transmit notification function for the connection
- * @param cnotify_cancel transmit notification cancellation function for the connection
- * @param ccheck function to test if the connection is still up
- * @param cdestroy function to close and free the connection
- * @return the client handle (client should call
- *         "client_drop" on the return value eventually)
- */
-struct GNUNET_SERVER_Client *
-GNUNET_SERVER_connect_callback (struct
-                                GNUNET_SERVER_Handle
-                                *server,
-                                void *chandle,
-                                GNUNET_SERVER_ReceiveCallback
-                                creceive,
-                                GNUNET_SERVER_ReceiveCancelCallback
-                                ccancel,
-                                GNUNET_SERVER_TransmitReadyCallback
-                                cnotify,
-                                GNUNET_SERVER_TransmitReadyCancelCallback
-                                cnotify_cancel,
-                                GNUNET_SERVER_CheckCallback
-                                ccheck,
-                                GNUNET_SERVER_DestroyCallback cdestroy)
-{
-  struct GNUNET_SERVER_Client *client;
-
-  client = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Client));
-  client->client_closure = chandle;
-  client->receive = creceive;
-  client->receive_cancel = ccancel;
-  client->notify_transmit_ready = cnotify;
-  client->notify_transmit_ready_cancel = cnotify_cancel;
-  client->check = ccheck;
-  client->destroy = cdestroy;
-  client->reference_count = 1;
-  add_client (server, client);
+  client->server = server;
+  client->last_activity = GNUNET_TIME_absolute_get ();
+  client->next = server->clients;
+  server->clients = client;
+  client->receive_pending = GNUNET_YES;
+  GNUNET_CONNECTION_receive (client->connection,
+			     GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+			     server->idle_timeout, &process_incoming, client);
   return client;
 }
 
@@ -1090,9 +938,7 @@ int
 GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
                                   void **addr, size_t * addrlen)
 {
-  if (client->receive != &sock_receive)
-    return GNUNET_SYSERR;       /* not a network client */
-  return GNUNET_CONNECTION_get_address (client->client_closure,
+  return GNUNET_CONNECTION_get_address (client->connection,
                                         addr, addrlen);
 }
 
@@ -1177,6 +1023,10 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
   struct NotifyList *n;
   unsigned int rc;
 
+#if DEBUG_SERVER
+  GNUNET_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->server->sched,
@@ -1185,7 +1035,7 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
     }
   if (GNUNET_YES == client->receive_pending)
     {
-      client->receive_cancel (client->client_closure);
+      GNUNET_CONNECTION_receive_cancel (client->connection);
       client->receive_pending = GNUNET_NO;
     }
 
@@ -1236,7 +1086,11 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
 #endif
       return;
     }
-  client->destroy (client->client_closure, client->persist);
+
+  if (client->persist == GNUNET_YES)
+    GNUNET_CONNECTION_persist_ (client->connection);  
+  GNUNET_CONNECTION_destroy (client->connection, GNUNET_NO);
+  GNUNET_SERVER_mst_destroy (client->mst);
   GNUNET_free (client);  
 }
 
@@ -1263,9 +1117,9 @@ GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
                                      GNUNET_CONNECTION_TransmitReadyNotify
                                      callback, void *callback_cls)
 {
-  return client->notify_transmit_ready (client->client_closure,
-                                        size,
-                                        timeout, callback, callback_cls);
+  return GNUNET_CONNECTION_notify_transmit_ready (client->connection,
+						  size,
+						  timeout, callback, callback_cls);
 }
 
 /**
@@ -1295,30 +1149,33 @@ GNUNET_SERVER_client_persist_ (struct GNUNET_SERVER_Client *client)
 void
 GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success)
 {
-  char *sb;
-
   if (client == NULL)
     return;
   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");
+#endif
       GNUNET_SERVER_client_disconnect (client);
       return;
     }
   if (client->suspended > 0)
-    return;
+    {
+#if DEBUG_SERVER
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		  "GNUNET_SERVER_receive_done called, but more clients pending\n");
+#endif
+      return;
+    }
   if (client->in_process_client_buffer == GNUNET_YES)
-    return;
-  if (client->side_buf_size > 0)
     {
-      /* resume processing from side-buf */
-      sb = client->side_buf;
-      client->side_buf = NULL;
-      /* this will also resume the receive job */
-      process_incoming (client, sb, client->side_buf_size, NULL, 0, 0);
-      /* finally, free the side-buf */
-      GNUNET_free (sb);
+#if DEBUG_SERVER
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		  "GNUNET_SERVER_receive_done called while still in processing loop\n");
+#endif
       return;
     }
   if (client->server == NULL)
@@ -1326,6 +1183,11 @@ GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success)
       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");
+#endif
+  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == client->restart_task);
   client->restart_task = GNUNET_SCHEDULER_add_now (client->server->sched,
 						   &restart_processing,
 						   client);