5 files changed, 133 insertions, 13 deletions

diff --git a/src/util/network.c b/src/util/network.c
index aae9d6872..00b2fac02 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -40,7 +40,7 @@
 #include "gnunet_network_lib.h"
 #include "gnunet_scheduler_lib.h"
 
-#define DEBUG_NETWORK GNUNET_NO
+#define DEBUG_NETWORK GNUNET_YES
 
 /**
  * List of address families to give as hints to
diff --git a/src/util/server.c b/src/util/server.c
index 282e036e8..ca4a5f0dd 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -34,6 +34,8 @@
 #include "gnunet_server_lib.h"
 #include "gnunet_time_lib.h"
 
+#define DEBUG_SERVER GNUNET_YES
+
 /**
  * List of arrays of message handlers.
  */
@@ -274,6 +276,10 @@ destroy_server (struct GNUNET_SERVER_Handle *server)
   struct HandlerList *hpos;
   struct NotifyList *npos;
 
+#if DEBUG_SERVER
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Server shutting down.\n");
+#endif
   GNUNET_assert (server->listen_socket == -1);
   GNUNET_break (0 == CLOSE (server->shutpipe[0]));
   GNUNET_break (0 == CLOSE (server->shutpipe[1]));
@@ -330,6 +336,10 @@ process_listen_socket (void *cls,
                                                    server->maxbuf);
   if (sock != NULL)
     {
+#if DEBUG_SERVER
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Server accepted incoming connection.\n");
+#endif
       client = GNUNET_SERVER_connect_socket (server, sock);
       /* decrement reference count, we don't keep "client" alive */
       GNUNET_SERVER_client_drop (client);
@@ -405,6 +415,11 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
       GNUNET_break (0 == CLOSE (fd));
       return -1;
     }
+#if DEBUG_SERVER
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Server starts to listen on port %u.\n",
+                  port);
+#endif
   return fd;
 }
 
@@ -551,6 +566,12 @@ GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
 
   type = ntohs (message->type);
   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);
+#endif
   pos = server->handlers;
   found = GNUNET_NO;
   while (pos != NULL)
@@ -633,6 +654,13 @@ shutdown_incoming_processing (struct GNUNET_SERVER_Client *client)
 }
 
 
+/**
+ * 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.
+ *
+ * @param client identifies which client receive buffer to process
+ */
 static void
 process_client_buffer (struct GNUNET_SERVER_Client *client)
 {
@@ -642,13 +670,33 @@ process_client_buffer (struct GNUNET_SERVER_Client *client)
 
   client->in_process_client_buffer = GNUNET_YES;
   server = client->server;
+#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");
+#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)
-        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);
+#endif
+          break;
+        }
+#if DEBUG_SERVER
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Passing %u bytes to callback for processing\n",
+                  msize);
+#endif
       if ((msize < sizeof (struct GNUNET_MessageHeader)) ||
           (GNUNET_OK != GNUNET_SERVER_inject (server, client, hdr)))
         {
@@ -671,12 +719,21 @@ process_client_buffer (struct GNUNET_SERVER_Client *client)
 
 /**
  * We are receiving an incoming message.  Process it.
+ *
+ * @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_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;
@@ -695,6 +752,12 @@ process_incoming (void *cls,
       shutdown_incoming_processing (client);
       return;
     }
+#if DEBUG_SERVER
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Server receives %u bytes from `%s'.\n",
+              available,
+              GNUNET_a2s(addr, addrlen));
+#endif
   GNUNET_SERVER_client_keep (client);
   client->last_activity = GNUNET_TIME_absolute_get ();
   /* process data (if available) */
@@ -703,6 +766,11 @@ process_incoming (void *cls,
       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;
@@ -711,6 +779,13 @@ process_incoming (void *cls,
         {
           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);
@@ -718,6 +793,10 @@ process_incoming (void *cls,
             }
           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);
@@ -736,6 +815,9 @@ process_incoming (void *cls,
 }
 
 
+/**
+ * FIXME: document.
+ */
 static void
 restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
@@ -768,6 +850,17 @@ add_client (struct GNUNET_SERVER_Handle *server,
                                         &process_incoming, client);
 }
 
+
+/**
+ * Create a request for receiving data from a socket.
+ *
+ * @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
+ * @return task identifier that can be used to cancel the operation
+ */
 static GNUNET_SCHEDULER_TaskIdentifier
 sock_receive (void *cls,
               size_t max,
@@ -777,6 +870,13 @@ sock_receive (void *cls,
   return GNUNET_NETWORK_receive (cls, max, timeout, receiver, receiver_cls);
 }
 
+
+/**
+ * Wrapper to cancel receiving from a socket.
+ * 
+ * @param cls handle to the GNUNET_NETWORK_SocketHandle to cancel
+ * @param tc task ID that was returned by GNUNET_NETWORK_receive
+ */
 static void
 sock_receive_cancel (void *cls, GNUNET_SCHEDULER_TaskIdentifier ti)
 {
@@ -784,6 +884,9 @@ sock_receive_cancel (void *cls, GNUNET_SCHEDULER_TaskIdentifier ti)
 }
 
 
+/**
+ * FIXME: document.
+ */
 static void *
 sock_notify_transmit_ready (void *cls,
                             size_t size,
@@ -796,6 +899,9 @@ sock_notify_transmit_ready (void *cls,
 }
 
 
+/**
+ * FIXME: document.
+ */
 static void
 sock_notify_transmit_ready_cancel (void *cls, void *h)
 {
diff --git a/src/util/test_client.c b/src/util/test_client.c
index 3545b9fa9..a1a268b14 100644
--- a/src/util/test_client.c
+++ b/src/util/test_client.c
@@ -61,6 +61,8 @@ copy_msg (void *cls, size_t size, void *buf)
   GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK);
   GNUNET_free (cpy);
   GNUNET_free (ctx);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Message bounced back to client\n");
   return sizeof (struct GNUNET_MessageHeader);
 }
 
@@ -76,6 +78,8 @@ echo_cb (void *cls,
   struct CopyContext *cc;
   struct GNUNET_MessageHeader *cpy;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Receiving message from client, bouncing back\n");
   GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
                  ntohs (message->size));
   cc = GNUNET_malloc (sizeof (struct CopyContext));
@@ -104,9 +108,11 @@ recv_bounce (void *cls, const struct GNUNET_MessageHeader *got)
   struct GNUNET_MessageHeader msg;
 
   GNUNET_assert (got != NULL);  /* timeout */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Receiving bounce, checking content\n");
   msg.type = htons (MY_TYPE);
-  msg.size = htons (sizeof (msg));
-  GNUNET_assert (0 == memcmp (got, &msg, sizeof (msg)));
+  msg.size = htons (sizeof (struct GNUNET_MessageHeader));
+  GNUNET_assert (0 == memcmp (got, &msg, sizeof (struct GNUNET_MessageHeader)));
   GNUNET_CLIENT_disconnect (client);
   client = NULL;
   GNUNET_SERVER_destroy (server);
@@ -121,7 +127,9 @@ make_msg (void *cls, size_t size, void *buf)
   struct GNUNET_MessageHeader *msg = buf;
   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg->type = htons (MY_TYPE);
-  msg->size = htons (sizeof (msg));
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating message for transmission\n");
   return sizeof (struct GNUNET_MessageHeader);
 }
 
@@ -185,7 +193,13 @@ main (int argc, char *argv[])
 {
   int ret = 0;
 
-  GNUNET_log_setup ("test_client", "WARNING", NULL);
+  GNUNET_log_setup ("test_client", 
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
   ret += check ();
 
   return ret;
diff --git a/src/util/test_server.c b/src/util/test_server.c
index 475d411db..c26d64270 100644
--- a/src/util/test_server.c
+++ b/src/util/test_server.c
@@ -83,8 +83,8 @@ my_receive (void *cls,
     case 1:
       *ok = 2;                  /* report success */
       msg.type = htons (MY_TYPE2);
-      msg.size = htons (sizeof (msg));
-      receiver (receiver_cls, &msg, sizeof (msg), NULL, 0, 0);
+      msg.size = htons (sizeof (struct GNUNET_MessageHeader));
+      receiver (receiver_cls, &msg, sizeof (struct GNUNET_MessageHeader), NULL, 0, 0);
       break;
     case 3:
       /* called after first receive instantly
@@ -130,7 +130,7 @@ my_transmit_ready_cb (void *cls,
   GNUNET_assert (size == sizeof (struct GNUNET_MessageHeader));
   notify (notify_cls, size, buf);
   msg.type = htons (MY_TYPE);
-  msg.size = htons (sizeof (msg));
+  msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   GNUNET_assert (0 == memcmp (&msg, buf, size));
   *ok = 5;                      /* report success */
   return &non_null_addr;
@@ -250,9 +250,9 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   handlers[1].callback_cls = cls;
   GNUNET_SERVER_add_handlers (server, handlers);
   msg.type = htons (MY_TYPE);
-  msg.size = htons (sizeof (msg));
+  msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   GNUNET_SERVER_inject (server, NULL, &msg);
-  memset (&msg, 0, sizeof (msg));
+  memset (&msg, 0, sizeof (struct GNUNET_MessageHeader));
 }
 
 
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c
index 22cf2cded..cccb2652d 100644
--- a/src/util/test_server_with_client.c
+++ b/src/util/test_server_with_client.c
@@ -30,7 +30,7 @@
 #include "gnunet_server_lib.h"
 #include "gnunet_time_lib.h"
 
-#define VERBOSE GNUNET_NO
+#define VERBOSE GNUNET_YES
 
 #define PORT 22335