15 files changed, 35 insertions, 130 deletions

diff --git a/src/util/client.c b/src/util/client.c
index 4ec40d032..8526de92b 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -290,8 +290,7 @@ do_connect (struct GNUNET_SCHEDULER_Handle *sched,
         {
           sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (sched,
                                                                     cfg,
-                                                                    unixpath,
-                                                                    GNUNET_SERVER_MAX_MESSAGE_SIZE - 1);
+                                                                    unixpath);
           GNUNET_free (unixpath);
           if (sock != NULL)
             return sock;
@@ -327,8 +326,7 @@ do_connect (struct GNUNET_SCHEDULER_Handle *sched,
   sock = GNUNET_CONNECTION_create_from_connect (sched,
                                                 cfg,
                                                 hostname,
-                                                port,
-                                                GNUNET_SERVER_MAX_MESSAGE_SIZE - 1);
+                                                port);
   GNUNET_free (hostname);
   return sock;
 }
diff --git a/src/util/connection.c b/src/util/connection.c
index 34c9fa62b..b1e68b0ef 100644
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -214,11 +214,6 @@ struct GNUNET_CONNECTION_Handle
   char *write_buffer;
 
   /**
-   * Max size of our write buffer.
-   */
-  size_t max_write_buffer_size;
-
-  /**
    * Current size of our write buffer.
    */
   size_t write_buffer_size;
@@ -319,21 +314,17 @@ void GNUNET_CONNECTION_persist_(struct GNUNET_CONNECTION_Handle *sock)
  *
  * @param sched scheduler to use
  * @param osSocket existing socket to box
- * @param maxbuf maximum write buffer size for the socket (use
- *        0 for sockets that need no write buffers, such as listen sockets)
  * @return the boxed socket handle
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
                                         *sched,
                                         struct GNUNET_NETWORK_Handle
-                                        *osSocket, size_t maxbuf)
+                                        *osSocket)
 {
   struct GNUNET_CONNECTION_Handle *ret;
   ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
-  GNUNET_assert (maxbuf < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
-  ret->max_write_buffer_size = maxbuf;
   ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
   ret->sock = osSocket;
   ret->sched = sched;
@@ -349,8 +340,6 @@ GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
  * @param access function to use to check if access is allowed
  * @param access_cls closure for access
  * @param lsock listen socket
- * @param maxbuf maximum write buffer size for the socket (use
- *        0 for sockets that need no write buffers, such as listen sockets)
  * @return the socket handle, NULL on error
  */
 struct GNUNET_CONNECTION_Handle *
@@ -358,8 +347,7 @@ GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
                                       *sched,
                                       GNUNET_CONNECTION_AccessCheck access,
                                       void *access_cls,
-                                      struct GNUNET_NETWORK_Handle *lsock,
-                                      size_t maxbuf)
+                                      struct GNUNET_NETWORK_Handle *lsock)
 {
   struct GNUNET_CONNECTION_Handle *ret;
   char addr[128];
@@ -423,10 +411,7 @@ GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
       return NULL;
     }
   ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
-
-  GNUNET_assert (maxbuf < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
-  ret->max_write_buffer_size = maxbuf;
   ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
   ret->addr = uaddr;
   ret->addrlen = addrlen;
@@ -870,16 +855,13 @@ try_connect_using_address (void *cls,
  * @param cfg configuration to use
  * @param hostname name of the host to connect to
  * @param port port to connect to
- * @param maxbuf maximum write buffer size for the socket (use
- *        0 for sockets that need no write buffers, such as listen sockets)
  * @return the socket handle
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
                                        const struct
                                        GNUNET_CONFIGURATION_Handle *cfg,
-                                       const char *hostname, uint16_t port,
-                                       size_t maxbuf)
+                                       const char *hostname, uint16_t port)
 {
   struct GNUNET_CONNECTION_Handle *ret;
 
@@ -887,10 +869,7 @@ GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
   ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
   ret->cfg = cfg;
   ret->sched = sched;
-
-  GNUNET_assert (maxbuf < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
-  ret->max_write_buffer_size = maxbuf;
   ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
   ret->port = port;
   ret->hostname = GNUNET_strdup (hostname);
@@ -912,16 +891,13 @@ GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
  * @param sched scheduler to use
  * @param cfg configuration to use
  * @param unixpath path to connect to
- * @param maxbuf maximum write buffer size for the socket (use
- *        0 for sockets that need no write buffers, such as listen sockets)
  * @return the socket handle, NULL on systems without UNIX support
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handle *sched,
                                                    const struct
                                                    GNUNET_CONFIGURATION_Handle *cfg,
-                                                   const char *unixpath,
-                                                   size_t maxbuf)
+                                                   const char *unixpath)
 {
 #ifdef AF_UNIX
   struct GNUNET_CONNECTION_Handle *ret;
@@ -946,9 +922,7 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handl
   ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
   ret->cfg = cfg;
   ret->sched = sched;
-  GNUNET_assert (maxbuf < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
-  ret->max_write_buffer_size = maxbuf;
   ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
   ret->port = 0;
   ret->hostname = NULL;
@@ -987,15 +961,13 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handl
  * @param af_family address family to use
  * @param serv_addr server address
  * @param addrlen length of server address
- * @param maxbuf maximum write buffer size for the socket (use
- *        0 for sockets that need no write buffers, such as listen sockets)
  * @return the socket handle
  */
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
                                         *sched, int af_family,
                                         const struct sockaddr *serv_addr,
-                                        socklen_t addrlen, size_t maxbuf)
+                                        socklen_t addrlen)
 {
   struct GNUNET_NETWORK_Handle *s;
   struct GNUNET_CONNECTION_Handle *ret;
@@ -1015,7 +987,7 @@ GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
       GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
       return NULL;
     }
-  ret = GNUNET_CONNECTION_create_from_existing (sched, s, maxbuf);
+  ret = GNUNET_CONNECTION_create_from_existing (sched, s);
   ret->addr = GNUNET_malloc (addrlen);
   memcpy (ret->addr, serv_addr, addrlen);
   ret->addrlen = addrlen;
@@ -1615,11 +1587,11 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
   if (sock->nth.notify_ready != NULL)
     return NULL;
   GNUNET_assert (notify != NULL);
-  if ((sock->write_buffer_size < size) && (size < sock->max_write_buffer_size))
+  if ((sock->write_buffer_size < size) && (size < GNUNET_SERVER_MAX_MESSAGE_SIZE))
     {
       temp_size = sock->write_buffer_size + size;
-      if (temp_size > sock->max_write_buffer_size)
-        temp_size = sock->max_write_buffer_size;
+      if (temp_size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+        temp_size = GNUNET_SERVER_MAX_MESSAGE_SIZE;
 
       sock->write_buffer = GNUNET_realloc(sock->write_buffer, temp_size);
       sock->write_buffer_size = temp_size;
diff --git a/src/util/server.c b/src/util/server.c
index 606d44369..3011f4927 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -122,11 +122,6 @@ struct GNUNET_SERVER_Handle
   struct GNUNET_TIME_Relative idle_timeout;
 
   /**
-   * maximum write buffer size for accepted sockets
-   */
-  size_t maxbuf;
-
-  /**
    * Task scheduled to do the listening.
    */
   GNUNET_SCHEDULER_TaskIdentifier listen_task;
@@ -273,8 +268,7 @@ process_listen_socket (void *cls,
           sock =
             GNUNET_CONNECTION_create_from_accept (tc->sched, server->access,
                                                   server->access_cls,
-                                                  server->listen_sockets[i],
-                                                  server->maxbuf);
+                                                  server->listen_sockets[i]);
           if (sock != NULL)
             {
 #if DEBUG_SERVER
@@ -396,7 +390,6 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
  * @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
@@ -407,7 +400,6 @@ 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)
@@ -418,7 +410,6 @@ GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
 
   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;
@@ -451,7 +442,6 @@ GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
  * @param access_cls closure for access
  * @param serverAddr address to listen on (including port), NULL terminated array
  * @param socklen length of serverAddr
- * @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
@@ -464,7 +454,6 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
                       void *access_cls,
                       struct sockaddr *const *serverAddr,
                       const socklen_t * socklen,
-                      size_t maxbuf,
                       struct GNUNET_TIME_Relative
                       idle_timeout, int require_found)
 {
@@ -503,7 +492,6 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
   return GNUNET_SERVER_create_with_sockets (sched,
                                             access, access_cls,
                                             lsocks,
-                                            maxbuf, 
                                             idle_timeout,
                                             require_found);
 }
@@ -877,8 +865,7 @@ GNUNET_SERVER_connect_socket (struct
 
   client = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Client));
   client->connection = connection;
-  client->mst = GNUNET_SERVER_mst_create (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                                          &client_message_tokenizer_callback,
+  client->mst = GNUNET_SERVER_mst_create (&client_message_tokenizer_callback,
                                           server);
   client->reference_count = 1;
   client->server = server;
diff --git a/src/util/server_mst.c b/src/util/server_mst.c
index d7a109f3b..505d98998 100644
--- a/src/util/server_mst.c
+++ b/src/util/server_mst.c
@@ -62,11 +62,6 @@ struct GNUNET_SERVER_MessageStreamTokenizer
   size_t curr_buf;
 
   /**
-   * Maximum size of the buffer.
-   */
-  size_t maxbuf;
-
-  /**
    * How many bytes in buffer have we already processed?
    */
   size_t off;
@@ -88,15 +83,12 @@ struct GNUNET_SERVER_MessageStreamTokenizer
 /**
  * Create a message stream tokenizer.
  *
- * @param maxbuf maximum message size to support (typically
- *    GNUNET_SERVER_MAX_MESSAGE_SIZE - 1)
  * @param cb function to call on completed messages
  * @param cb_cls closure for cb
  * @return handle to tokenizer
  */
 struct GNUNET_SERVER_MessageStreamTokenizer *
-GNUNET_SERVER_mst_create (size_t maxbuf,
-                          GNUNET_SERVER_MessageTokenizerCallback cb,
+GNUNET_SERVER_mst_create (GNUNET_SERVER_MessageTokenizerCallback cb,
                           void *cb_cls)
 {
   struct GNUNET_SERVER_MessageStreamTokenizer *ret;
@@ -104,7 +96,6 @@ GNUNET_SERVER_mst_create (size_t maxbuf,
   ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_MessageStreamTokenizer));
   ret->hdr = GNUNET_malloc(GNUNET_SERVER_MIN_BUFFER_SIZE);
   ret->curr_buf = GNUNET_SERVER_MIN_BUFFER_SIZE;
-  ret->maxbuf = maxbuf;
   ret->cb = cb;
   ret->cb_cls = cb_cls;
   return ret;
@@ -149,11 +140,11 @@ GNUNET_SERVER_mst_receive (struct GNUNET_SERVER_MessageStreamTokenizer *mst,
               (unsigned int) size,
               (unsigned int) (mst->pos - mst->off));
 #endif
-  if ((size > mst->curr_buf) && (size < mst->maxbuf)) /* Received bigger message than we can currently handle! */
+  if ((size > mst->curr_buf) && (size < GNUNET_SERVER_MAX_MESSAGE_SIZE)) /* Received bigger message than we can currently handle! */
     {
       newsize = mst->curr_buf + size; /* How much space do we need? */
-      if (newsize > mst->maxbuf)
-        newsize = mst->maxbuf; /* Check it's not bigger than maxbuf */
+      if (newsize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+        newsize = GNUNET_SERVER_MAX_MESSAGE_SIZE; /* Check it's not bigger than GNUNET_SERVER_MAX_MESSAGE_SIZE */
 
       mst->hdr = GNUNET_realloc(mst->hdr, newsize);
       mst->curr_buf = newsize;
diff --git a/src/util/service.c b/src/util/service.c
index c34c5aa32..99a364f15 100644
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -499,11 +499,6 @@ struct GNUNET_SERVICE_Context
   struct GNUNET_TIME_Relative timeout;
 
   /**
-   * Maximum buffer size for the server.
-   */
-  size_t maxbuf;
-
-  /**
    * Overall success/failure of the service start.
    */
   int ret;
@@ -1077,14 +1072,13 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
 
 
 /**
- * Setup addr, addrlen, maxbuf, idle_timeout
+ * Setup addr, addrlen, idle_timeout
  * based on configuration!
  *
  * Configuration may specify:
  * - PORT (where to bind to for TCP)
  * - UNIXPATH (where to bind to for UNIX domain sockets)
  * - TIMEOUT (after how many ms does an inactive service timeout);
- * - MAXBUF (maximum incoming message size supported)
  * - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
  * - BINDTO (hostname or IP address to bind to, otherwise we take everything)
  * - ACCEPT_FROM  (only allow connections from specified IPv4 subnets)
@@ -1097,7 +1091,6 @@ GNUNET_SERVICE_get_server_addresses (const char *serviceName,
 static int
 setup_service (struct GNUNET_SERVICE_Context *sctx)
 {
-  unsigned long long maxbuf;
   struct GNUNET_TIME_Relative idleout;
   int tolerant;
   const char *lpid;
@@ -1124,23 +1117,6 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
     }
   else
     sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
-                                       sctx->serviceName, "MAXBUF"))
-    {
-      if (GNUNET_OK !=
-          GNUNET_CONFIGURATION_get_value_number (sctx->cfg,
-                                                 sctx->serviceName,
-                                                 "MAXBUF", &maxbuf))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Specified value for `%s' of service `%s' is invalid\n"),
-                      "MAXBUF",
-                      sctx->serviceName);
-          return GNUNET_SYSERR;
-        }
-    }
-  else
-    maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
 
   if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
                                        sctx->serviceName, "TOLERANT"))
@@ -1201,15 +1177,6 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
                                              &sctx->addrlens)) )
     return GNUNET_SYSERR;
   sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
-  sctx->maxbuf = (size_t) maxbuf;
-  if (sctx->maxbuf != maxbuf)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Value in configuration for `%s' and service `%s' too large!\n"),
-                  "MAXBUF", sctx->serviceName);
-      return GNUNET_SYSERR;
-    }
 
   process_acl4 (&sctx->v4_denied, sctx, "REJECT_FROM");
   process_acl4 (&sctx->v4_allowed, sctx, "ACCEPT_FROM");
@@ -1324,7 +1291,6 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                                       &check_access,
                                                       sctx,
                                                       sctx->lsocks,
-                                                      sctx->maxbuf,
                                                       sctx->timeout, sctx->require_found);
   else
     sctx->server = GNUNET_SERVER_create (tc->sched,
@@ -1332,7 +1298,6 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                          sctx,
                                          sctx->addrs,
                                          sctx->addrlens,
-                                         sctx->maxbuf,
                                          sctx->timeout, sctx->require_found);
   if (sctx->server == NULL)
     {
@@ -1577,7 +1542,6 @@ GNUNET_SERVICE_run (int argc,
   sctx.ready_confirm_fd = -1;
   sctx.ret = GNUNET_OK;
   sctx.timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-  sctx.maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
   sctx.task = task;
   sctx.serviceName = serviceName;
   sctx.cfg = cfg = GNUNET_CONFIGURATION_create ();
@@ -1656,7 +1620,6 @@ GNUNET_SERVICE_start (const char *serviceName,
   sctx->ready_confirm_fd = -1;  /* no daemonizing */
   sctx->ret = GNUNET_OK;
   sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-  sctx->maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE;
   sctx->serviceName = serviceName;
   sctx->cfg = cfg;
   sctx->sched = sched;
@@ -1672,7 +1635,6 @@ GNUNET_SERVICE_start (const char *serviceName,
                                                       &check_access,
                                                       sctx,
                                                       sctx->lsocks,
-                                                      sctx->maxbuf,
                                                       sctx->timeout, sctx->require_found);
   else
     sctx->server = GNUNET_SERVER_create (sched,
@@ -1680,7 +1642,6 @@ GNUNET_SERVICE_start (const char *serviceName,
                                          sctx,
                                          sctx->addrs,
                                          sctx->addrlens,
-                                         sctx->maxbuf,
                                          sctx->timeout,
                                          sctx->require_found);
                                          
diff --git a/src/util/test_client.c b/src/util/test_client.c
index 4d436e810..ead6751a4 100644
--- a/src/util/test_client.c
+++ b/src/util/test_client.c
@@ -155,7 +155,6 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                  NULL,
                                  sap,
                                  slens,
-                                 1024,
                                  GNUNET_TIME_relative_multiply
                                  (GNUNET_TIME_UNIT_MILLISECONDS, 10000),
                                  GNUNET_NO);
diff --git a/src/util/test_connection.c b/src/util/test_connection.c
index d8e86a6eb..0cc02059d 100644
--- a/src/util/test_connection.c
+++ b/src/util/test_connection.c
@@ -119,7 +119,7 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test accepts connection\n");
 #endif
   asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
-                                                NULL, NULL, ls, 1024);
+                                                NULL, NULL, ls);
   GNUNET_assert (asock != NULL);
   GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
 #if VERBOSE
@@ -157,11 +157,11 @@ static void
 task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
   GNUNET_assert (lsock != NULL);
   csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
                                                  cfg,
-                                                 "localhost", PORT, 1024);
+                                                 "localhost", PORT);
   GNUNET_assert (csock != NULL);
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test asks for write notification\n");
diff --git a/src/util/test_connection_addressing.c b/src/util/test_connection_addressing.c
index 83eea375c..4c10bd074 100644
--- a/src/util/test_connection_addressing.c
+++ b/src/util/test_connection_addressing.c
@@ -116,7 +116,7 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct sockaddr_in expect;
 
   asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
-                                                NULL, NULL, ls, 1024);
+                                                NULL, NULL, ls);
   GNUNET_assert (asock != NULL);
   GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
   GNUNET_assert (GNUNET_OK ==
@@ -153,7 +153,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct sockaddr_in v4;
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
   GNUNET_assert (lsock != NULL);
 
 #if HAVE_SOCKADDR_IN_SIN_LEN
@@ -165,7 +165,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   csock = GNUNET_CONNECTION_create_from_sockaddr (tc->sched,
                                                   AF_INET,
                                                   (const struct sockaddr
-                                                   *) &v4, sizeof (v4), 1024);
+                                                   *) &v4, sizeof (v4));
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
                  GNUNET_CONNECTION_notify_transmit_ready (csock,
diff --git a/src/util/test_connection_receive_cancel.c b/src/util/test_connection_receive_cancel.c
index db5f573df..e4d7111d4 100644
--- a/src/util/test_connection_receive_cancel.c
+++ b/src/util/test_connection_receive_cancel.c
@@ -91,7 +91,7 @@ run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
   asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
-                                                NULL, NULL, ls, 1024);
+                                                NULL, NULL, ls);
   GNUNET_assert (asock != NULL);
   GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
   GNUNET_CONNECTION_destroy (lsock, GNUNET_YES);
@@ -119,10 +119,10 @@ static void
 task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
   GNUNET_assert (lsock != NULL);
   csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
-                                                 "localhost", PORT, 1024);
+                                                 "localhost", PORT);
   GNUNET_assert (csock != NULL);
   GNUNET_SCHEDULER_add_read_net (tc->sched,
                                  GNUNET_TIME_UNIT_FOREVER_REL,
diff --git a/src/util/test_connection_timeout.c b/src/util/test_connection_timeout.c
index b7a1ea94e..5291ad3c4 100644
--- a/src/util/test_connection_timeout.c
+++ b/src/util/test_connection_timeout.c
@@ -107,10 +107,10 @@ task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
   GNUNET_assert (lsock != NULL);
   csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
-                                                 "localhost", PORT, 1024);
+                                                 "localhost", PORT);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
                  GNUNET_CONNECTION_notify_transmit_ready (csock,
diff --git a/src/util/test_connection_timeout_no_connect.c b/src/util/test_connection_timeout_no_connect.c
index c37824c25..468e965ca 100644
--- a/src/util/test_connection_timeout_no_connect.c
+++ b/src/util/test_connection_timeout_no_connect.c
@@ -54,7 +54,7 @@ static void
 task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
-                                                 "localhost", PORT, 1024);
+                                                 "localhost", PORT);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
                  GNUNET_CONNECTION_notify_transmit_ready (csock,
diff --git a/src/util/test_connection_transmit_cancel.c b/src/util/test_connection_transmit_cancel.c
index b801e1b68..37a513e0f 100644
--- a/src/util/test_connection_transmit_cancel.c
+++ b/src/util/test_connection_transmit_cancel.c
@@ -51,7 +51,7 @@ task_transmit_cancel (void *cls,
   struct GNUNET_CONNECTION_Handle *csock;
 
   csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
-                                                 "localhost", PORT, 1024);
+                                                 "localhost", PORT);
   GNUNET_assert (csock != NULL);
   th = GNUNET_CONNECTION_notify_transmit_ready (csock,
                                                 12,
diff --git a/src/util/test_server.c b/src/util/test_server.c
index 8fa329f5f..78e2d52bf 100644
--- a/src/util/test_server.c
+++ b/src/util/test_server.c
@@ -95,7 +95,7 @@ reply_msg (void *cls, size_t size, void *buf)
 
   GNUNET_assert (ok == 3);
   ok = 4;
-  GNUNET_assert (size > sizeof (struct GNUNET_MessageHeader));
+  GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg.type = htons (MY_TYPE);
   msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   memcpy (buf, &msg, sizeof (struct GNUNET_MessageHeader));
@@ -137,7 +137,7 @@ transmit_second_message (void *cls,
 {
   struct GNUNET_MessageHeader msg;
 
-  GNUNET_assert (size > sizeof (struct GNUNET_MessageHeader));
+  GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg.type = htons (MY_TYPE2);
   msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   memcpy (buf, &msg, sizeof (struct GNUNET_MessageHeader));
@@ -154,7 +154,7 @@ transmit_initial_message (void *cls,
 
   GNUNET_assert (ok == 1);
   ok = 2;
-  GNUNET_assert (size > sizeof (struct GNUNET_MessageHeader));
+  GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg.type = htons (MY_TYPE);
   msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   memcpy (buf, &msg, sizeof (struct GNUNET_MessageHeader));
@@ -193,7 +193,6 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                  NULL,
                                  sap,
                                  slens,
-                                 1024,
                                  TIMEOUT,
                                  GNUNET_NO);
   GNUNET_assert (server != NULL);
diff --git a/src/util/test_server_disconnect.c b/src/util/test_server_disconnect.c
index 049d28667..2fef5642e 100644
--- a/src/util/test_server_disconnect.c
+++ b/src/util/test_server_disconnect.c
@@ -115,7 +115,7 @@ transmit_initial_message (void *cls,
 
   GNUNET_assert (ok == 1);
   ok = 2;
-  GNUNET_assert (size > sizeof (struct GNUNET_MessageHeader));
+  GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg.type = htons (MY_TYPE);
   msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   memcpy (buf, &msg, sizeof (struct GNUNET_MessageHeader));
@@ -146,7 +146,6 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                  NULL,
                                  sap,
                                  slens,
-                                 1024,
                                  TIMEOUT,
                                  GNUNET_NO);
   GNUNET_assert (server != NULL);
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c
index 37cfa0a24..4157be250 100644
--- a/src/util/test_server_with_client.c
+++ b/src/util/test_server_with_client.c
@@ -179,7 +179,6 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                  NULL,
                                  sap,
                                  slens,
-                                 1024,
                                  GNUNET_TIME_relative_multiply
                                  (GNUNET_TIME_UNIT_MILLISECONDS, 250),
                                  GNUNET_NO);