new MHD with support for chunked encoding

17 files changed, 1515 insertions, 941 deletions

diff --git a/ChangeLog b/ChangeLog
index e784f5b5..14bc69e6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+Wed Dec 19 21:12:04 MST 2007
+         Implemented chunked (HTTP 1.1) downloads (including
+         sending of HTTP footers).  Also allowed queuing of
+         a response early to suppress the otherwise automatic
+         "100 CONTINUE" response.  Removed the mostly useless
+         "(un)register handler" methods from the API.  Changed
+         the internal implementation to use a finite state
+         machine (cleaner code, slightly less memory consumption). - CG
+        
 Sun Dec 16 03:24:13 MST 2007
          Implemented handling of chunked (HTTP 1.1) uploads.
          Note that the upload callback must be able to 
diff --git a/README b/README
index 4fd9edbe..cf941c2e 100644
--- a/README
+++ b/README
@@ -24,7 +24,7 @@ reporting (and use MHD_USE_DEBUG).  Error reporting is not enabled by
 default to reduce the size of the library (error messages take
 space!).  If you are concerned about space, you should set "CFLAGS" to
 "-Os --fomit-frame-pointer" to have gcc generate tight code.  The
-resulting binary should be less than 25k (on x86).
+resulting binary should be about 25k (on x86).
 
 
 Portability
@@ -50,11 +50,6 @@ indicates that a testcase should be written before implementing the
 feature.
 
 
-For http/1.1-compliance:
-========================
-connection.c:
-- support sending of chunked responses (#1302, TEST, ARCH)
-
 For POST:
 =========
 - add support to decode multipart/form-data with 
@@ -71,6 +66,10 @@ Missing Testcases:
 - add testcases for http/1.1 pipelining (need
   to figure out how to ensure curl pipelines)
 - add testcases for resource limit enforcement
+- add testcases for client queuing early response,
+  suppressing 100 CONTINUE
+- extend testcase for chunked encoding to validate
+  handling of footers
 
 Documentation:
 ==============
diff --git a/configure.ac b/configure.ac
index adc1e3ca..09860619 100644
--- a/configure.ac
+++ b/configure.ac
@@ -21,8 +21,8 @@
 #
 #
 AC_PREREQ(2.57)
-AC_INIT([libmicrohttpd], [0.1.2],[libmicrohttpd@gnunet.org])
-AM_INIT_AUTOMAKE([libmicrohttpd], [0.1.2])
+AC_INIT([libmicrohttpd], [0.2.0],[libmicrohttpd@gnunet.org])
+AM_INIT_AUTOMAKE([libmicrohttpd], [0.2.0])
 AM_CONFIG_HEADER([config.h])
 
 AH_TOP([#define _GNU_SOURCE  1])
diff --git a/src/daemon/Makefile.am b/src/daemon/Makefile.am
index 4902dc52..30ec59f1 100644
--- a/src/daemon/Makefile.am
+++ b/src/daemon/Makefile.am
@@ -12,7 +12,7 @@ lib_LTLIBRARIES = \
   libmicrohttpd.la
 
 libmicrohttpd_la_LDFLAGS = \
-  -export-dynamic -version-info 2:1:1 $(retaincommand)
+  -export-dynamic -version-info 3:0:0 $(retaincommand)
 libmicrohttpd_la_SOURCES = \
   connection.c connection.h \
   reason_phrase.c reason_phrase.h \
@@ -48,7 +48,6 @@ check_PROGRAMS = \
   daemontest_postform \
   daemontest_post_loop \
   daemontest_put \
-  daemontest_put_chunked \
   daemontest_large_put \
   daemontest_get11 \
   daemontest_post11 \
@@ -56,7 +55,9 @@ check_PROGRAMS = \
   daemontest_post_loop11 \
   daemontest_put11 \
   daemontest_large_put11 \
-  daemontest_long_header
+  daemontest_long_header \
+  daemontest_get_chunked \
+  daemontest_put_chunked 
 
 TESTS = $(check_PROGRAMS)
 
@@ -71,6 +72,12 @@ daemontest_get_LDADD = \
   $(top_builddir)/src/daemon/libmicrohttpd.la \
   @LIBCURL@ 
 
+daemontest_get_chunked_SOURCES = \
+  daemontest_get_chunked.c
+daemontest_get_chunked_LDADD = \
+  $(top_builddir)/src/daemon/libmicrohttpd.la \
+  @LIBCURL@ 
+
 daemontest_post_SOURCES = \
   daemontest_post.c
 daemontest_post_LDADD = \
diff --git a/src/daemon/connection.c b/src/daemon/connection.c
index 318439a8..d07a2544 100644
--- a/src/daemon/connection.c
+++ b/src/daemon/connection.c
@@ -2,7 +2,6 @@
      This file is part of libmicrohttpd
      (C) 2007 Daniel Pittman and Christian Grothoff
 
-
      This library is free software; you can redistribute it and/or
      modify it under the terms of the GNU Lesser General Public
      License as published by the Free Software Foundation; either
@@ -62,6 +61,14 @@
  */
 #define REQUEST_LACKS_HOST ""
 
+#define EXTRA_CHECKS MHD_YES
+
+#if EXTRA_CHECKS
+#define EXTRA_CHECK(a) if (!(a)) abort();
+#else
+#define EXTRA_CHECK(a)
+#endif
+
 /**
  * Add extra debug messages with reasons for closing connections
  * (non-error reasons).
@@ -73,6 +80,10 @@
  */
 #define DEBUG_SEND_DATA MHD_NO
 
+/**
+ * Should all state transitions be printed to stderr?
+ */
+#define DEBUG_STATES MHD_NO
 
 /**
  * Get all of the headers from the request.
@@ -109,7 +120,6 @@ MHD_get_connection_values (struct MHD_Connection *connection,
   return ret;
 }
 
-
 /**
  * Get a particular header value.  If multiple
  * values match the kind, return any one of them.
@@ -149,11 +159,11 @@ int
 MHD_queue_response (struct MHD_Connection *connection,
                     unsigned int status_code, struct MHD_Response *response)
 {
-  if ((connection == NULL) ||
-      (response == NULL) ||
-      (connection->response != NULL) ||
-      (connection->have_received_body == MHD_NO)
-      || (connection->have_received_headers == MHD_NO))
+  if ( (connection == NULL) ||
+       (response == NULL) ||
+       (connection->response != NULL) ||
+       ( (connection->state != MHD_CONNECTION_HEADERS_PROCESSED) &&
+         (connection->state != MHD_CONNECTION_FOOTERS_RECEIVED) ) )
     return MHD_NO;
   MHD_increment_response_rc (response);
   connection->response = response;
@@ -165,6 +175,21 @@ MHD_queue_response (struct MHD_Connection *connection,
          have already sent the full message body */
       connection->response_write_position = response->total_size;
     }
+  if ( (response->total_size == -1) &&
+       (0 == strcasecmp(connection->version,
+                        MHD_HTTP_VERSION_1_1)) )
+    connection->have_chunked_response = MHD_YES;
+  else
+    connection->have_chunked_response = MHD_NO;
+  if (connection->state == MHD_CONNECTION_HEADERS_PROCESSED) 
+    {
+      /* response was queued "early", 
+         refuse to read body / footers or further
+         requests! */
+      SHUTDOWN (connection->socket_fd, SHUT_RD);
+      connection->read_closed = MHD_YES;
+      connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
+    }
   return MHD_YES;
 }
 
@@ -173,14 +198,14 @@ MHD_queue_response (struct MHD_Connection *connection,
  * message for this connection?
  */
 static int
-MHD_need_100_continue (struct MHD_Connection *connection)
+need_100_continue (struct MHD_Connection *connection)
 {
   const char *expect;
 
-  return ((connection->version != NULL) &&
+  return ((connection->response == NULL) &&
+          (connection->version != NULL) &&
           (0 == strcasecmp (connection->version,
                             MHD_HTTP_VERSION_1_1)) &&
-          (connection->have_received_headers == MHD_YES) &&
           (NULL != (expect = MHD_lookup_connection_value (connection,
                                                           MHD_HEADER_KIND,
                                                           MHD_HTTP_HEADER_EXPECT)))
@@ -199,6 +224,7 @@ connection_close_error (struct MHD_Connection *connection)
   SHUTDOWN (connection->socket_fd, SHUT_RDWR);
   CLOSE (connection->socket_fd);
   connection->socket_fd = -1;
+  connection->state = MHD_CONNECTION_CLOSED;
   if (connection->daemon->notify_completed != NULL)
     connection->daemon->notify_completed (connection->daemon->
                                           notify_completed_cls, connection,
@@ -216,12 +242,14 @@ connection_close_error (struct MHD_Connection *connection)
  * @return MHD_NO if readying the response failed
  */
 static int
-ready_response (struct MHD_Connection *connection)
+try_ready_normal_body (struct MHD_Connection *connection)
 {
   int ret;
   struct MHD_Response *response;
 
   response = connection->response;
+  if (response->crc == NULL)
+    return MHD_YES;
   ret = response->crc (response->crc_cls,
                        connection->response_write_position,
                        response->data,
@@ -230,7 +258,8 @@ ready_response (struct MHD_Connection *connection)
                             connection->response_write_position));
   if (ret == -1)
     {
-      /* end of message, signal other side by closing! */
+      /* either error or http 1.0 transfer, close
+         socket! */
 #if DEBUG_CLOSE
 #if HAVE_MESSAGES
       MHD_DLOG (connection->daemon, "Closing connection (end of response)\n");
@@ -239,94 +268,281 @@ ready_response (struct MHD_Connection *connection)
       response->total_size = connection->response_write_position;
       connection_close_error (connection);
       return MHD_NO;
-    }
+    }    
   response->data_start = connection->response_write_position;
   response->data_size = ret;
   if (ret == 0)
+    return MHD_NO;
+  return MHD_YES;
+}
+
+/**
+ * Prepare the response buffer of this connection for
+ * sending.  Assumes that the response mutex is 
+ * already held.  If the transmission is complete,
+ * this function may close the socket (and return
+ * MHD_NO).
+ * 
+ * @return MHD_NO if readying the response failed
+ */
+static int
+try_ready_chunked_body (struct MHD_Connection *connection)
+{
+  int ret;
+  char * buf;
+  struct MHD_Response *response;
+  unsigned int size;
+  char cbuf[9];
+
+  response = connection->response;  
+  if (connection->write_buffer_size == 0)
     {
-      /* avoid busy-waiting when using external select
-         (we assume that the main application will 
-         wake up the external select once more data
-         is ready).  With internal selects, we
-         have no choice; if the app uses a thread
-         per connection, ret==0 is likely a bug --
-         the application should block until data
-         is ready! */
-      if ((0 ==
-           (connection->daemon->
-            options & (MHD_USE_SELECT_INTERNALLY |
-                       MHD_USE_THREAD_PER_CONNECTION))))
-        connection->response_unready = MHD_YES;
+      size = connection->daemon->pool_size;
+      do 
+        {
+          size /= 2;
+          if (size < 128) 
+            {
+              /* not enough memory */
+#if DEBUG_CLOSE
+#if HAVE_MESSAGES
+              MHD_DLOG (connection->daemon, "Closing connection (out of memory)\n");
+#endif
+#endif
+              connection_close_error (connection);
+              return MHD_NO; 
+            }
+          buf = MHD_pool_allocate (connection->pool,
+                                   size,
+                                   MHD_NO);
+        } 
+      while (buf == NULL);
+      connection->write_buffer_size = size;
+      connection->write_buffer = buf;
+    }
+  
+  ret = response->crc (response->crc_cls,
+                       connection->response_write_position,
+                       &connection->write_buffer[8],
+                       connection->write_buffer_size - 8 - 2);
+  if (ret == -1)
+    {
+      /* end of message, signal other side! */
+      strcpy(connection->write_buffer,
+             "0\r\n");      
+      connection->write_buffer_append_offset = 3;
+      connection->write_buffer_send_offset = 0;
+      response->total_size = connection->response_write_position;
+      return MHD_YES;
+    }
+  if (ret == 0)
+    {
+      connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY;
       return MHD_NO;
     }
-  connection->response_unready = MHD_NO;
+  if (ret > 0xFFFFFF)
+    ret = 0xFFFFFF;
+  snprintf(cbuf,
+           8,
+           "%X\r\n",
+           ret);
+  memcpy(&connection->write_buffer[8 - strlen(cbuf)],
+         cbuf,
+         strlen(cbuf));
+  memcpy(&connection->write_buffer[8 + ret],
+         "\r\n",
+         2);
+  connection->response_write_position += ret;
+  connection->write_buffer_send_offset = 8 - strlen(cbuf);
+  connection->write_buffer_append_offset = 8 + ret + 2; 
   return MHD_YES;
 }
 
 /**
- * Obtain the select sets for this connection
- *
- * @return MHD_YES on success
+ * Check if we need to set some additional headers
+ * for http-compiliance.
  */
-int
-MHD_connection_get_fdset (struct MHD_Connection *connection,
-                          fd_set * read_fd_set,
-                          fd_set * write_fd_set,
-                          fd_set * except_fd_set, int *max_fd)
+static void
+add_extra_headers (struct MHD_Connection *connection)
 {
-  int fd;
-  void *buf;
+  const char *have;
+  char buf[128];
 
-  fd = connection->socket_fd;
-  if (fd == -1)
-    return MHD_YES;
-  if ((connection->read_close == MHD_NO) &&
-      ((connection->have_received_headers == MHD_NO) ||
-       (connection->read_buffer_offset < connection->read_buffer_size)))
+  connection->have_chunked_upload = MHD_NO;
+  if (connection->response->total_size == -1)
+    {      
+      have = MHD_get_response_header (connection->response,
+                                      MHD_HTTP_HEADER_CONNECTION);
+      if ( (have == NULL) ||
+           (0 != strcasecmp(have, "close")) )
+        {
+          if ( (connection->version != NULL) &&
+               (0 == strcasecmp(connection->version,
+                                MHD_HTTP_VERSION_1_1)) )
+            {
+              connection->have_chunked_upload = MHD_YES;
+              have = MHD_get_response_header (connection->response,
+                                              MHD_HTTP_HEADER_TRANSFER_ENCODING);
+              if (have == NULL)
+                MHD_add_response_header (connection->response,
+                                         MHD_HTTP_HEADER_TRANSFER_ENCODING, 
+                                         "chunked");
+            }
+          else        
+            {
+              MHD_add_response_header (connection->response,
+                                       MHD_HTTP_HEADER_CONNECTION, "close");
+            }
+        }
+    }
+  else if (NULL == MHD_get_response_header (connection->response,
+                                            MHD_HTTP_HEADER_CONTENT_LENGTH))
     {
-      FD_SET (fd, read_fd_set);
-      if (fd > *max_fd)
-        *max_fd = fd;
+      _REAL_SNPRINTF (buf,
+                      128,
+                      "%llu",
+                      (unsigned long long) connection->response->total_size);
+      MHD_add_response_header (connection->response,
+                               MHD_HTTP_HEADER_CONTENT_LENGTH, buf);
+    }
+}
+
+/**
+ * Produce HTTP "Date:" header.
+ * @param date where to write the header
+ * @param max maximum number of characters to write
+ */
+static void
+get_date_string (char *date, unsigned int max)
+{
+  static const char *days[] =
+    { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+  static const char *mons[] =
+    { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
+    "Nov", "Dec"
+  };
+  struct tm now;
+  time_t t;
+
+  time (&t);
+  gmtime_r (&t, &now);
+  snprintf (date,
+            max - 1,
+            "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
+            days[now.tm_wday % 7],
+            now.tm_mday,
+            mons[now.tm_mon % 12],
+            now.tm_year, now.tm_hour, now.tm_min, now.tm_sec);
+}
+
+/**
+ * try growing the read buffer
+ * @return MHD_YES on success, MHD_NO on failure
+ */
+static int
+try_grow_read_buffer(struct MHD_Connection * connection)
+{
+  void * buf;
+
+  buf = MHD_pool_reallocate (connection->pool,
+                             connection->read_buffer,
+                             connection->read_buffer_size,
+                             connection->read_buffer_size * 2 +
+                             MHD_BUF_INC_SIZE + 1);
+  if (buf == NULL)
+    return MHD_NO;
+  /* we can actually grow the buffer, do it! */
+  connection->read_buffer = buf;
+  connection->read_buffer_size =
+    connection->read_buffer_size * 2 + MHD_BUF_INC_SIZE;
+  return MHD_YES;  
+}
+
+/**
+ * Allocate the connection's write buffer and
+ * fill it with all of the headers (or footers,
+ * if we have already sent the body) from the
+ * HTTPd's response.
+ */
+static int
+build_header_response (struct MHD_Connection *connection)
+{
+  size_t size;
+  size_t off;
+  struct MHD_HTTP_Header *pos;
+  char code[128];
+  char date[128];
+  char *data;
+  enum MHD_ValueKind kind;
+  const char *reason_phrase;
+    
+  if (connection->state == MHD_CONNECTION_FOOTERS_RECEIVED)
+    {
+      add_extra_headers (connection);
+      reason_phrase =
+        MHD_get_reason_phrase_for (connection->responseCode);
+      _REAL_SNPRINTF (code, 128, "%s %u %s\r\n", MHD_HTTP_VERSION_1_1,
+                      connection->responseCode, reason_phrase);
+      off = strlen (code);
+      /* estimate size */
+      size = off + 2;               /* extra \r\n at the end */
+      kind = MHD_HEADER_KIND;
+      if (NULL == MHD_get_response_header (connection->response,
+                                           MHD_HTTP_HEADER_DATE))
+        get_date_string (date, sizeof (date));
+      else
+        date[0] = '\0';
+      size += strlen (date);
     }
   else
     {
-      if ((connection->read_close == MHD_NO) &&
-          ((connection->have_received_headers == MHD_YES) &&
-           (connection->read_buffer_offset == connection->read_buffer_size)))
-        {
-          /* try growing the read buffer, just in case */
-          buf = MHD_pool_reallocate (connection->pool,
-                                     connection->read_buffer,
-                                     connection->read_buffer_size,
-                                     connection->read_buffer_size * 2 +
-                                     MHD_BUF_INC_SIZE);
-          if (buf != NULL)
-            {
-              /* we can actually grow the buffer, do it! */
-              connection->read_buffer = buf;
-              connection->read_buffer_size =
-                connection->read_buffer_size * 2 + MHD_BUF_INC_SIZE;
-              FD_SET (fd, read_fd_set);
-              if (fd > *max_fd)
-                *max_fd = fd;
-            }
-        }
+      size = 2;
+      kind = MHD_FOOTER_KIND;
+      off = 0;
+    }
+  pos = connection->response->first_header;
+  while (pos != NULL)
+    {
+      if (pos->kind == kind)
+        size += strlen (pos->header) + strlen (pos->value) + 4;   /* colon, space, linefeeds */
+      pos = pos->next;
+    }
+  /* produce data */  
+  data = MHD_pool_allocate (connection->pool, size + 1, MHD_YES);
+  if (data == NULL)
+    {
+#if HAVE_MESSAGES
+      MHD_DLOG (connection->daemon, "Not enough memory for write!\n");
+#endif
+      return MHD_NO;
+    }
+  if (connection->state == MHD_CONNECTION_FOOTERS_RECEIVED)
+    {
+      memcpy (data, code, off);
     }
-  if ((connection->response != NULL) &&
-      (connection->response_unready == MHD_YES))
+  pos = connection->response->first_header;
+  while (pos != NULL)
     {
-      pthread_mutex_lock (&connection->response->mutex);
-      ready_response (connection);
-      pthread_mutex_unlock (&connection->response->mutex);
+      if (pos->kind == kind) 
+        {
+          SPRINTF (&data[off], "%s: %s\r\n", pos->header, pos->value);
+          off += strlen (pos->header) + strlen (pos->value) + 4;
+        }
+      pos = pos->next;
     }
-  if (((connection->response != NULL) &&
-       (connection->response_unready == MHD_NO)) ||
-      MHD_need_100_continue (connection))
+  if (connection->state == MHD_CONNECTION_FOOTERS_RECEIVED)
     {
-      FD_SET (fd, write_fd_set);
-      if (fd > *max_fd)
-        *max_fd = fd;
+      strcpy (&data[off], date);
+      off += strlen (date);
     }
+  sprintf (&data[off], "\r\n");
+  off += 2;
+  if (off != size)
+    abort ();
+  connection->write_buffer = data;
+  connection->write_buffer_append_offset = size;
+  connection->write_buffer_send_offset = 0;
+  connection->write_buffer_size = size + 1;
   return MHD_YES;
 }
 
@@ -338,15 +554,14 @@ MHD_connection_get_fdset (struct MHD_Connection *connection,
  * @param status_code the response code to send (413 or 414)
  */
 static void
-MHD_excessive_data_handler (struct MHD_Connection *connection,
-                            unsigned int status_code)
+excessive_data_handler (struct MHD_Connection *connection,
+                        unsigned int status_code)
 {
   struct MHD_Response *response;
 
   /* die, header far too long to be reasonable */
-  connection->read_close = MHD_YES;
-  connection->have_received_headers = MHD_YES;
-  connection->have_received_body = MHD_YES;
+  connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
+  connection->read_closed = MHD_YES;
 #if HAVE_MESSAGES
   MHD_DLOG (connection->daemon,
             "Received excessively long header, closing connection.\n");
@@ -354,7 +569,166 @@ MHD_excessive_data_handler (struct MHD_Connection *connection,
   response = MHD_create_response_from_data (strlen (REQUEST_TOO_BIG),
                                             REQUEST_TOO_BIG, MHD_NO, MHD_NO);
   MHD_queue_response (connection, status_code, response);
+  EXTRA_CHECK(connection->response != NULL);
   MHD_destroy_response (response);
+  if (MHD_NO == build_header_response (connection))
+    {
+      /* oops - close! */
+#if HAVE_MESSAGES
+      MHD_DLOG (connection->daemon,
+                "Closing connection (failed to create response header)\n");
+#endif
+      connection->state = MHD_CONNECTION_CLOSED;
+    } 
+  else
+    {
+      connection->state = MHD_CONNECTION_HEADERS_SENDING;
+    } 
+}
+
+/**
+ * Add "fd" to the "fd_set".  If "fd" is
+ * greater than "*max", set "*max" to fd.
+ */
+static void
+do_fd_set(int fd,
+          fd_set * set,
+          int * max_fd) 
+{
+  FD_SET (fd, set);
+  if (fd > *max_fd)
+    *max_fd = fd;
+}
+
+/**
+ * Obtain the select sets for this connection
+ *
+ * @return MHD_YES on success
+ */
+int
+MHD_connection_get_fdset (struct MHD_Connection *connection,
+                          fd_set * read_fd_set,
+                          fd_set * write_fd_set,
+                          fd_set * except_fd_set, int *max_fd)
+{
+  int fd;
+
+  if (connection->pool == NULL)
+    connection->pool = MHD_pool_create (connection->daemon->pool_size);
+  if (connection->pool == NULL)
+    {
+#if HAVE_MESSAGES
+      MHD_DLOG (connection->daemon, "Failed to create memory pool!\n");
+#endif
+      connection_close_error (connection);
+      return MHD_NO;
+    }
+  fd = connection->socket_fd;
+  if (fd == -1)
+    return MHD_YES;
+  while (1) {
+#if DEBUG_STATES
+    fprintf(stderr,
+            "`%s' in state %u\n",
+            __FUNCTION__,
+            connection->state);
+#endif    
+    switch (connection->state)
+      {
+      case MHD_CONNECTION_INIT:
+      case MHD_CONNECTION_URL_RECEIVED:
+      case MHD_CONNECTION_HEADER_PART_RECEIVED:
+        /* while reading headers, we always grow the
+           read buffer if needed, no size-check required */
+        if ( (connection->read_closed) &&
+             (connection->read_buffer_offset == 0) )
+          {
+            connection->state = MHD_CONNECTION_CLOSED;
+            continue;
+          }     
+        if ( (connection->read_buffer_offset == connection->read_buffer_size) &&
+             (MHD_NO == try_grow_read_buffer(connection)) )
+          {
+            excessive_data_handler (connection,
+                                    (connection->url != NULL)
+                                    ? MHD_HTTP_REQUEST_ENTITY_TOO_LARGE
+                                    : MHD_HTTP_REQUEST_URI_TOO_LONG);
+            continue;
+          }
+        if (MHD_NO == connection->read_closed)
+          do_fd_set (fd, read_fd_set, max_fd);
+        break;
+      case MHD_CONNECTION_HEADERS_RECEIVED:
+        /* we should never get here */
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_HEADERS_PROCESSED:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_CONTINUE_SENDING:
+        do_fd_set (fd, write_fd_set, max_fd);
+        break;
+      case MHD_CONNECTION_CONTINUE_SENT:
+        if (connection->read_buffer_offset == connection->read_buffer_size)
+          try_grow_read_buffer(connection);
+        if (connection->read_buffer_offset < connection->read_buffer_size)
+          do_fd_set (fd, read_fd_set, max_fd);
+        break;
+      case MHD_CONNECTION_BODY_RECEIVED:        
+      case MHD_CONNECTION_FOOTER_PART_RECEIVED: 
+        /* while reading footers, we always grow the
+           read buffer if needed, no size-check required */
+        if (MHD_YES == connection->read_closed)
+          {
+            connection->state = MHD_CONNECTION_CLOSED;
+            continue;
+          }
+        do_fd_set (fd, read_fd_set, max_fd);
+        /* transition to FOOTERS_RECEIVED
+           happens in read handler */
+        break;
+      case MHD_CONNECTION_FOOTERS_RECEIVED:     
+        /* no socket action, wait for client
+           to provide response */
+        break;
+      case MHD_CONNECTION_HEADERS_SENDING:
+        /* headers in buffer, keep writing */
+        do_fd_set(fd, write_fd_set, max_fd);
+        break;
+      case MHD_CONNECTION_HEADERS_SENT:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_NORMAL_BODY_READY:
+        do_fd_set (fd, write_fd_set, max_fd);
+        break;
+      case MHD_CONNECTION_NORMAL_BODY_UNREADY:
+        /* not ready, no socket action */
+        break;
+      case MHD_CONNECTION_CHUNKED_BODY_READY:
+        do_fd_set (fd, write_fd_set, max_fd);
+        break;
+      case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
+        /* not ready, no socket action */
+        break;
+      case MHD_CONNECTION_BODY_SENT:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_FOOTERS_SENDING:
+        do_fd_set (fd, write_fd_set, max_fd);
+        break;
+      case MHD_CONNECTION_FOOTERS_SENT:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_CLOSED:
+        if (connection->socket_fd != -1) 
+          connection_close_error(connection);     
+        return MHD_YES; /* do nothing, not even reading */
+      default:
+        EXTRA_CHECK(0);
+      }
+    break;
+  }
+  return MHD_YES;
 }
 
 /**
@@ -366,7 +740,7 @@ MHD_excessive_data_handler (struct MHD_Connection *connection,
  * return NULL.  Otherwise return a pointer to the line.
  */
 static char *
-MHD_get_next_header_line (struct MHD_Connection *connection)
+get_next_header_line (struct MHD_Connection *connection)
 {
   char *rbuf;
   size_t pos;
@@ -390,10 +764,10 @@ MHD_get_next_header_line (struct MHD_Connection *connection)
                                       MHD_BUF_INC_SIZE);
           if (rbuf == NULL)
             {
-              MHD_excessive_data_handler (connection,
-                                          (connection->url != NULL)
-                                          ? MHD_HTTP_REQUEST_ENTITY_TOO_LARGE
-                                          : MHD_HTTP_REQUEST_URI_TOO_LONG);
+              excessive_data_handler (connection,
+                                      (connection->url != NULL)
+                                      ? MHD_HTTP_REQUEST_ENTITY_TOO_LARGE
+                                      : MHD_HTTP_REQUEST_URI_TOO_LONG);
             }
           else
             {
@@ -418,8 +792,8 @@ MHD_get_next_header_line (struct MHD_Connection *connection)
  * @return MHD_NO on failure (out of memory), MHD_YES for success
  */
 static int
-MHD_connection_add_header (struct MHD_Connection *connection,
-                           char *key, char *value, enum MHD_ValueKind kind)
+connection_add_header (struct MHD_Connection *connection,
+                       char *key, char *value, enum MHD_ValueKind kind)
 {
   struct MHD_HTTP_Header *hdr;
 
@@ -431,8 +805,8 @@ MHD_connection_add_header (struct MHD_Connection *connection,
       MHD_DLOG (connection->daemon,
                 "Not enough memory to allocate header record!\n");
 #endif
-      MHD_excessive_data_handler (connection,
-                                  MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
+      excessive_data_handler (connection,
+                              MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
       return MHD_NO;
     }
   hdr->next = connection->headers_received;
@@ -468,8 +842,8 @@ parse_arguments (enum MHD_ValueKind kind,
         }
       MHD_http_unescape (args);
       MHD_http_unescape (equals);
-      if (MHD_NO == MHD_connection_add_header (connection,
-                                               args, equals, kind))
+      if (MHD_NO == connection_add_header (connection,
+                                           args, equals, kind))
         return MHD_NO;
       args = amper;
     }
@@ -482,7 +856,7 @@ parse_arguments (enum MHD_ValueKind kind,
  * @return MHD_YES for success, MHD_NO for failure (malformed, out of memory)
  */
 static int
-MHD_parse_cookie_header (struct MHD_Connection *connection)
+parse_cookie_header (struct MHD_Connection *connection)
 {
   const char *hdr;
   char *cpy;
@@ -500,8 +874,8 @@ MHD_parse_cookie_header (struct MHD_Connection *connection)
 #if HAVE_MESSAGES
       MHD_DLOG (connection->daemon, "Not enough memory to parse cookies!\n");
 #endif
-      MHD_excessive_data_handler (connection,
-                                  MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
+      excessive_data_handler (connection,
+                              MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
       return MHD_NO;
     }
   memcpy (cpy, hdr, strlen (hdr) + 1);
@@ -536,8 +910,8 @@ MHD_parse_cookie_header (struct MHD_Connection *connection)
           equals[strlen (equals) - 1] = '\0';
           equals++;
         }
-      if (MHD_NO == MHD_connection_add_header (connection,
-                                               pos, equals, MHD_COOKIE_KIND))
+      if (MHD_NO == connection_add_header (connection,
+                                           pos, equals, MHD_COOKIE_KIND))
         return MHD_NO;
       pos = semicolon;
     }
@@ -587,235 +961,29 @@ parse_initial_message_line (struct MHD_Connection *connection, char *line)
   return MHD_YES;
 }
 
-
-/**
- * This function is designed to parse the input buffer of a given
- * connection for HTTP headers -- and in the case of chunked encoding,
- * also for HTTP "footers".
- *
- * Once the header is complete, it should have set the
- * headers_received, url and method values and set
- * have_received_headers to MHD_YES.  If no body is expected, it
- * should also set "have_received_body" to MHD_YES.  Otherwise, it
- * should set "remaining_upload_size" to the expected size of the
- * body.  If the size of the body is unknown, it should be set to -1.
- */
-static void
-MHD_parse_connection_headers (struct MHD_Connection *connection)
-{
-  char *last;
-  char *line;
-  char *colon;
-  char *tmp;
-  const char *clen;
-  unsigned long long cval;
-  struct MHD_Response *response;
-
-  if (((connection->have_received_body == MHD_YES) &&
-       (connection->have_chunked_upload == MHD_NO)) ||
-      (connection->have_received_headers == MHD_YES))
-    abort ();
-  colon = NULL;                 /* make gcc happy */
-  last = NULL;
-  while (NULL != (line = MHD_get_next_header_line (connection)))
-    {
-      if (last != NULL)
-        {
-          if ((line[0] == ' ') || (line[0] == '\t'))
-            {
-              /* value was continued on the next line, see
-                 http://www.jmarshall.com/easy/http/ */
-              last = MHD_pool_reallocate (connection->pool,
-                                          last,
-                                          strlen (last) + 1,
-                                          strlen (line) + strlen (last) + 1);
-              if (last == NULL)
-                {
-                  MHD_excessive_data_handler (connection,
-                                              MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
-                  break;
-                }
-              tmp = line;
-              while ((tmp[0] == ' ') || (tmp[0] == '\t'))
-                tmp++;          /* skip whitespace at start of 2nd line */
-              strcat (last, tmp);
-              continue;         /* possibly more than 2 lines... */
-            }
-          else
-            {
-              if (MHD_NO == MHD_connection_add_header (connection,
-                                                       last,
-                                                       colon,
-                                                       MHD_HEADER_KIND))
-                return;
-              last = NULL;
-            }
-        }
-      if (connection->url == NULL)
-        {
-          /* line must be request line (first line of header) */
-          if (MHD_NO == parse_initial_message_line (connection, line))
-            goto DIE;
-          continue;
-        }
-      /* check if this is the end of the header */
-      if (strlen (line) == 0)
-        {
-          /* end of header */
-          connection->have_received_headers = MHD_YES;
-          clen = MHD_lookup_connection_value (connection,
-                                              MHD_HEADER_KIND,
-                                              MHD_HTTP_HEADER_CONTENT_LENGTH);
-          if (clen != NULL)
-            {
-              if (1 != sscanf (clen, "%llu", &cval))
-                {
-#if HAVE_MESSAGES
-                  MHD_DLOG (connection->daemon,
-                            "Failed to parse `%s' header `%s', closing connection.\n",
-                            MHD_HTTP_HEADER_CONTENT_LENGTH, clen);
-#endif
-                  goto DIE;
-                }
-              connection->remaining_upload_size = cval;
-              connection->have_received_body = cval == 0 ? MHD_YES : MHD_NO;
-            }
-          else
-            {
-              if (NULL == MHD_lookup_connection_value (connection,
-                                                       MHD_HEADER_KIND,
-                                                       MHD_HTTP_HEADER_TRANSFER_ENCODING))
-                {
-                  /* this request does not have a body */
-                  connection->remaining_upload_size = 0;
-                  connection->have_received_body = MHD_YES;
-                }
-              else
-                {
-                  if (connection->have_chunked_upload == MHD_NO)
-                    {
-                      connection->remaining_upload_size = -1;   /* unknown size */
-                      if (0 ==
-                          strcasecmp (MHD_lookup_connection_value
-                                      (connection, MHD_HEADER_KIND,
-                                       MHD_HTTP_HEADER_TRANSFER_ENCODING),
-                                      "chunked"))
-                        connection->have_chunked_upload = MHD_YES;
-                    }
-                  else
-                    {
-                      /* we were actually processing the footers at the
-                         END of a chunked encoding; give connection 
-                         handler an extra chance... */
-                      connection->have_chunked_upload = MHD_NO; /* no more! */
-                      MHD_call_connection_handler (connection);
-                    }
-                }
-            }
-          if ((0 != (MHD_USE_PEDANTIC_CHECKS & connection->daemon->options))
-              && (NULL != connection->version)
-              && (0 == strcasecmp (MHD_HTTP_VERSION_1_1, connection->version))
-              && (NULL ==
-                  MHD_lookup_connection_value (connection, MHD_HEADER_KIND,
-                                               MHD_HTTP_HEADER_HOST)))
-            {
-              /* die, http 1.1 request without host and we are pedantic */
-              connection->have_received_body = MHD_YES;
-              connection->read_close = MHD_YES;
-#if HAVE_MESSAGES
-              MHD_DLOG (connection->daemon,
-                        "Received `%s' request without `%s' header.\n",
-                        MHD_HTTP_VERSION_1_1, MHD_HTTP_HEADER_HOST);
-#endif
-              response =
-                MHD_create_response_from_data (strlen (REQUEST_LACKS_HOST),
-                                               REQUEST_LACKS_HOST, MHD_NO,
-                                               MHD_NO);
-              MHD_queue_response (connection, MHD_HTTP_BAD_REQUEST, response);
-              MHD_destroy_response (response);
-            }
-          break;
-        }
-      /* line should be normal header line, find colon */
-      colon = strstr (line, ":");
-      if (colon == NULL)
-        {
-          /* error in header line, die hard */
-#if HAVE_MESSAGES
-          MHD_DLOG (connection->daemon,
-                    "Received malformed line (no colon), closing connection.\n");
-#endif
-          goto DIE;
-        }
-      /* zero-terminate header */
-      colon[0] = '\0';
-      colon++;                  /* advance to value */
-      while ((colon[0] != '\0') && ((colon[0] == ' ') || (colon[0] == '\t')))
-        colon++;
-      /* we do the actual adding of the connection
-         header at the beginning of the while
-         loop since we need to be able to inspect
-         the *next* header line (in case it starts
-         with a space...) */
-      last = line;
-    }
-  if ((last != NULL) &&
-      (MHD_NO == MHD_connection_add_header (connection,
-                                            last, colon, MHD_HEADER_KIND)))
-    return;                     /* error */
-  MHD_parse_cookie_header (connection);
-  return;
-DIE:
-#if HAVE_MESSAGES
-  MHD_DLOG (connection->daemon,
-            "Closing connection (problem parsing headers)\n");
-#endif
-  connection_close_error (connection);
-}
-
-
-/**
- * Find the handler responsible for this request.
- */
-static struct MHD_Access_Handler *
-MHD_find_access_handler (struct MHD_Connection *connection)
-{
-  struct MHD_Access_Handler *pos;
-
-  pos = connection->daemon->handlers;
-  while (pos != NULL)
-    {
-      if (0 == strcmp (connection->url, pos->uri_prefix))
-        return pos;
-      pos = pos->next;
-    }
-  return &connection->daemon->default_handler;
-}
-
-
 /**
  * Call the handler of the application for this
- * connection.
+ * connection.  Handles chunking of the upload
+ * as well as normal uploads.
  */
-void
-MHD_call_connection_handler (struct MHD_Connection *connection)
+static void
+call_connection_handler (struct MHD_Connection *connection)
 {
-  struct MHD_Access_Handler *ah;
   unsigned int processed;
   unsigned int available;
   unsigned int used;
   int instant_retry;
   unsigned int i;
+  int malformed;
 
   if (connection->response != NULL)
-    return;                     /* already queued a response */
-  if (connection->have_received_headers == MHD_NO)
-    abort ();                   /* bad timing... */
+    return; /* already queued a response */
   do
     {
       instant_retry = MHD_NO;
       available = connection->read_buffer_offset;
-      if (connection->have_chunked_upload == MHD_YES)
+      if ( (connection->have_chunked_upload == MHD_YES) &&
+           (connection->remaining_upload_size == -1) )
         {
           if ((connection->current_chunk_offset ==
                connection->current_chunk_size)
@@ -876,18 +1044,17 @@ MHD_call_connection_handler (struct MHD_Connection *connection)
                 }
               if (i >= available)
                 return;         /* need more data... */
-              /* The following if-statement is a bit crazy -- we
-                 use the second clause only for the side-effect,
-                 0-terminating the buffer for the following sscanf
-                 attempts; yes, there should be only a single 
-                 "="-sign (assignment!) in the read_buffer[i]-line. */
-              if ((i >= 6) ||
-                  ((connection->read_buffer[i] = '\0')) ||
-                  ((1 != sscanf (connection->read_buffer,
-                                 "%X",
-                                 &connection->current_chunk_size)) &&
-                   (1 != sscanf (connection->read_buffer,
-                                 "%x", &connection->current_chunk_size))))
+              malformed = (i >= 6);
+              if (! malformed) 
+                {
+                  connection->read_buffer[i] = '\0';
+                  malformed = (1 != sscanf (connection->read_buffer,
+                                            "%X",
+                                            &connection->current_chunk_size)) &&
+                    (1 != sscanf (connection->read_buffer,
+                                  "%x", &connection->current_chunk_size));                
+                }
+              if (malformed)
                 {
                   /* malformed encoding */
 #if HAVE_MESSAGES
@@ -908,11 +1075,7 @@ MHD_call_connection_handler (struct MHD_Connection *connection)
               instant_retry = MHD_YES;
               if (connection->current_chunk_size == 0)
                 {
-                  /* we're back to reading HEADERS (footers!) */
-                  connection->have_received_body = MHD_YES;
                   connection->remaining_upload_size = 0;
-                  connection->have_received_headers = MHD_NO;
-                  MHD_parse_connection_headers (connection);
                   return;
                 }
               continue;
@@ -925,8 +1088,7 @@ MHD_call_connection_handler (struct MHD_Connection *connection)
           available = 0;
         }
       used = processed;
-      ah = MHD_find_access_handler (connection);
-      if (MHD_NO == ah->dh (ah->dh_cls,
+      if (MHD_NO == connection->daemon->default_handler (connection->daemon->default_handler_cls,
                             connection,
                             connection->url,
                             connection->method,
@@ -942,6 +1104,8 @@ MHD_call_connection_handler (struct MHD_Connection *connection)
           connection_close_error (connection);
           return;
         }
+      if (processed > used)
+        abort(); /* fatal client API violation! */
       if (processed != 0)
         instant_retry = MHD_NO; /* client did not process everything */
       used -= processed;
@@ -953,79 +1117,26 @@ MHD_call_connection_handler (struct MHD_Connection *connection)
                  &connection->read_buffer[used], processed + available);
       if (connection->remaining_upload_size != -1)
         connection->remaining_upload_size -= used;
-      connection->read_buffer_offset = processed + available;
-      if ((connection->remaining_upload_size == 0) ||
-          ((connection->read_buffer_offset == 0) &&
-           (connection->remaining_upload_size == -1)
-           && (connection->socket_fd == -1)))
-        {
-          connection->have_received_body = MHD_YES;
-          if (connection->read_buffer != NULL)
-            MHD_pool_reallocate (connection->pool,
-                                 connection->read_buffer,
-                                 (connection->read_buffer ==
-                                  NULL) ? 0 : connection->read_buffer_size +
-                                 1, 0);
-          connection->read_buffer_offset = 0;
-          connection->read_buffer_size = 0;
-          connection->read_buffer = NULL;
-        }
+      connection->read_buffer_offset = processed + available;      
     }
   while (instant_retry == MHD_YES);
 }
 
 /**
- * This function handles a particular connection when it has been
- * determined that there is data to be read off a socket. All implementations
- * (multithreaded, external select, internal select) call this function
- * to handle reads.
+ * Try reading data from the socket into the
+ * read buffer of the connection.
+ *
+ * @return MHD_YES if something changed,
+ *         MHD_NO if we were interrupted or if
+ *                no space was available
  */
-int
-MHD_connection_handle_read (struct MHD_Connection *connection)
+static int
+do_read(struct MHD_Connection * connection)
 {
   int bytes_read;
-  void *tmp;
-
-  if (connection->pool == NULL)
-    connection->pool = MHD_pool_create (connection->daemon->pool_size);
-  if (connection->pool == NULL)
-    {
-#if HAVE_MESSAGES
-      MHD_DLOG (connection->daemon, "Failed to create memory pool!\n");
-#endif
-      connection_close_error (connection);
-      return MHD_NO;
-    }
-  if ((connection->read_buffer_offset >= connection->read_buffer_size) &&
-      (connection->have_received_headers == MHD_NO))
-    {
-      /* need to grow read buffer */
-      tmp = MHD_pool_reallocate (connection->pool,
-                                 connection->read_buffer,
-                                 connection->read_buffer_size,
-                                 connection->read_buffer_size * 2 +
-                                 MHD_BUF_INC_SIZE + 1);
-      if (tmp == NULL)
-        {
-#if HAVE_MESSAGES
-          MHD_DLOG (connection->daemon,
-                    "Not enough memory for reading headers!\n");
-#endif
-          MHD_excessive_data_handler (connection,
-                                      MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
-          return MHD_NO;
-        }
-      connection->read_buffer = tmp;
-      connection->read_buffer_size =
-        connection->read_buffer_size * 2 + MHD_BUF_INC_SIZE;
-    }
-  if (connection->read_buffer_offset >= connection->read_buffer_size)
-    {
-#if HAVE_MESSAGES
-      MHD_DLOG (connection->daemon, "Unexpected call to %s.\n", __FUNCTION__);
-#endif
-      return MHD_NO;
-    }
+  
+  if (connection->read_buffer_size == connection->read_buffer_offset)
+    return MHD_NO;
   bytes_read = RECV (connection->socket_fd,
                      &connection->read_buffer[connection->read_buffer_offset],
                      connection->read_buffer_size -
@@ -1044,150 +1155,297 @@ MHD_connection_handle_read (struct MHD_Connection *connection)
   if (bytes_read == 0)
     {
       /* other side closed connection */
-      connection->read_close = MHD_YES;
-      if ((connection->have_received_headers == MHD_YES)
-          && (connection->read_buffer_offset > 0))
-        MHD_call_connection_handler (connection);
-#if DEBUG_CLOSE
-#if HAVE_MESSAGES
-      MHD_DLOG (connection->daemon,
-                "Shutting down connection for reading (other side closed connection)\n");
-#endif
-#endif
-      shutdown (connection->socket_fd, SHUT_RD);
-      if ((connection->have_received_headers == MHD_NO) ||
-          (connection->have_received_body == MHD_NO))
-        {
-          /* no request => no response! */
-          CLOSE (connection->socket_fd);
-          connection->socket_fd = -1;
-        }
-      return MHD_YES;
+      connection->read_closed = MHD_YES;
+      return MHD_NO;
     }
   connection->read_buffer_offset += bytes_read;
-  if (connection->have_received_headers == MHD_NO)
-    MHD_parse_connection_headers (connection);
-  if ((connection->have_received_headers == MHD_YES)
-      && (connection->method != NULL))
-    MHD_call_connection_handler (connection);
   return MHD_YES;
 }
 
 /**
- * Check if we need to set some additional headers
- * for http-compiliance.
+ * We have received (possibly the beginning of) a line in the
+ * header (or footer).  Validate (check for ":") and prepare
+ * to process.
  */
 static void
-MHD_add_extra_headers (struct MHD_Connection *connection)
+process_header_line(struct MHD_Connection * connection,
+                    char * line) 
 {
-  const char *have;
-  char buf[128];
+  char *colon;
 
-  if (connection->response->total_size == -1)
+  /* line should be normal header line, find colon */
+  colon = strstr (line, ":");
+  if (colon == NULL)
     {
-      have = MHD_get_response_header (connection->response,
-                                      MHD_HTTP_HEADER_CONNECTION);
-      if (have == NULL)
-        MHD_add_response_header (connection->response,
-                                 MHD_HTTP_HEADER_CONNECTION, "close");
-    }
-  else if (NULL == MHD_get_response_header (connection->response,
-                                            MHD_HTTP_HEADER_CONTENT_LENGTH))
-    {
-      _REAL_SNPRINTF (buf,
-                      128,
-                      "%llu",
-                      (unsigned long long) connection->response->total_size);
-      MHD_add_response_header (connection->response,
-                               MHD_HTTP_HEADER_CONTENT_LENGTH, buf);
+      /* error in header line, die hard */
+#if HAVE_MESSAGES
+      MHD_DLOG (connection->daemon,
+                "Received malformed line (no colon), closing connection.\n");
+#endif
+      connection->state = MHD_CONNECTION_CLOSED;
+      return;
     }
+  /* zero-terminate header */
+  colon[0] = '\0';
+  colon++;                  /* advance to value */
+  while ((colon[0] != '\0') && ((colon[0] == ' ') || (colon[0] == '\t')))
+    colon++;
+  /* we do the actual adding of the connection
+     header at the beginning of the while
+     loop since we need to be able to inspect
+     the *next* header line (in case it starts
+     with a space...) */
+  connection->last = line;
+  connection->colon = colon;
 }
 
+/**
+ * Process a header value that spans multiple lines.
+ * The previous line(s) are in connection->last.  
+ *
+ * @param line the current input line
+ * @param kind if the line is complete, add a header
+ *        of the given kind
+ */
 static void
-get_date_string (char *date, unsigned int max)
+process_broken_line(struct MHD_Connection * connection,
+                    char * line,
+                    enum MHD_ValueKind kind) 
 {
-  static const char *days[] =
-    { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-  static const char *mons[] =
-    { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
-    "Nov", "Dec"
-  };
-  struct tm now;
-  time_t t;
+  char * last;
+  char * tmp;
 
-  time (&t);
-  gmtime_r (&t, &now);
-  snprintf (date,
-            max - 1,
-            "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
-            days[now.tm_wday % 7],
-            now.tm_mday,
-            mons[now.tm_mon % 12],
-            now.tm_year, now.tm_hour, now.tm_min, now.tm_sec);
+  last = connection->last;
+  if ((line[0] == ' ') || (line[0] == '\t'))
+    {
+      /* value was continued on the next line, see
+         http://www.jmarshall.com/easy/http/ */
+      last = MHD_pool_reallocate (connection->pool,
+                                  last,
+                                  strlen (last) + 1,
+                                  strlen (line) + strlen (last) + 1);
+      if (last == NULL)
+        {
+          excessive_data_handler (connection,
+                                  MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
+          return;
+        }
+      tmp = line;
+      while ((tmp[0] == ' ') || (tmp[0] == '\t'))
+        tmp++;          /* skip whitespace at start of 2nd line */
+      strcat (last, tmp);
+      connection->last = last;
+      return;         /* possibly more than 2 lines... */
+    }
+  if (MHD_NO == connection_add_header (connection,
+                                       last,
+                                       connection->colon,
+                                       kind))
+    {
+      excessive_data_handler (connection,
+                              MHD_HTTP_REQUEST_ENTITY_TOO_LARGE);
+      return;
+    }
+  /* we still have the current line to deal with... */
+  if (strlen(line) != 0)
+    process_header_line(connection,
+                        line);
 }
 
 /**
- * Allocate the connection's write buffer and
- * fill it with all of the headers from the
- * HTTPd's response.
+ * Parse the various headers; figure out the size
+ * of the upload and make sure the headers follow
+ * the protocol.  Advance to the appropriate state.
  */
-static int
-MHD_build_header_response (struct MHD_Connection *connection)
+static void
+parse_connection_headers(struct MHD_Connection * connection)
 {
-  size_t size;
-  size_t off;
-  struct MHD_HTTP_Header *pos;
-  char code[128];
-  char date[128];
-  char *data;
+  const char *clen;
+  unsigned long long cval;
+  struct MHD_Response *response;
 
-  MHD_add_extra_headers (connection);
-  const char *reason_phrase =
-    MHD_get_reason_phrase_for (connection->responseCode);
-  _REAL_SNPRINTF (code, 128, "%s %u %s\r\n", MHD_HTTP_VERSION_1_1,
-                  connection->responseCode, reason_phrase);
-  off = strlen (code);
-  /* estimate size */
-  size = off + 2;               /* extra \r\n at the end */
-  pos = connection->response->first_header;
-  while (pos != NULL)
+  parse_cookie_header (connection);
+  if ((0 != (MHD_USE_PEDANTIC_CHECKS & connection->daemon->options))
+      && (NULL != connection->version)
+      && (0 == strcasecmp (MHD_HTTP_VERSION_1_1, connection->version))
+      && (NULL ==
+          MHD_lookup_connection_value (connection, MHD_HEADER_KIND,
+                                       MHD_HTTP_HEADER_HOST)))
     {
-      size += strlen (pos->header) + strlen (pos->value) + 4;   /* colon, space, linefeeds */
-      pos = pos->next;
+      /* die, http 1.1 request without host and we are pedantic */
+      connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
+      connection->read_closed = MHD_YES;
+#if HAVE_MESSAGES
+      MHD_DLOG (connection->daemon,
+                "Received `%s' request without `%s' header.\n",
+                MHD_HTTP_VERSION_1_1, MHD_HTTP_HEADER_HOST);
+#endif
+      response =
+        MHD_create_response_from_data (strlen (REQUEST_LACKS_HOST),
+                                       REQUEST_LACKS_HOST, MHD_NO,
+                                       MHD_NO);
+      MHD_queue_response (connection, MHD_HTTP_BAD_REQUEST, response);
+      MHD_destroy_response (response);
+      return;
     }
-  if (NULL == MHD_get_response_header (connection->response,
-                                       MHD_HTTP_HEADER_DATE))
-    get_date_string (date, sizeof (date));
-  else
-    date[0] = '\0';
-  size += strlen (date);
-  /* produce data */
-  data = MHD_pool_allocate (connection->pool, size + 1, MHD_YES);
-  if (data == NULL)
+
+  clen = MHD_lookup_connection_value (connection,
+                                      MHD_HEADER_KIND,
+                                      MHD_HTTP_HEADER_CONTENT_LENGTH);
+  if (clen != NULL)
     {
+      if (1 != sscanf (clen, "%llu", &cval))
+        {
 #if HAVE_MESSAGES
-      MHD_DLOG (connection->daemon, "Not enough memory for write!\n");
+          MHD_DLOG (connection->daemon,
+                    "Failed to parse `%s' header `%s', closing connection.\n",
+                    MHD_HTTP_HEADER_CONTENT_LENGTH, clen);
 #endif
-      return MHD_NO;
+          connection->state = MHD_CONNECTION_CLOSED;
+          return;
+        }
+      connection->remaining_upload_size = cval;
     }
-  memcpy (data, code, off);
-  pos = connection->response->first_header;
-  while (pos != NULL)
+  else
     {
-      SPRINTF (&data[off], "%s: %s\r\n", pos->header, pos->value);
-      off += strlen (pos->header) + strlen (pos->value) + 4;
-      pos = pos->next;
+      if (NULL == MHD_lookup_connection_value (connection,
+                                               MHD_HEADER_KIND,
+                                               MHD_HTTP_HEADER_TRANSFER_ENCODING))
+        {
+          /* this request does not have a body */
+          connection->remaining_upload_size = 0;
+        }
+      else
+        {
+          connection->remaining_upload_size = -1;   /* unknown size */
+          if (0 ==
+              strcasecmp (MHD_lookup_connection_value
+                          (connection, MHD_HEADER_KIND,
+                           MHD_HTTP_HEADER_TRANSFER_ENCODING),
+                          "chunked"))
+            connection->have_chunked_upload = MHD_YES;  
+        }
+    }  
+}
+
+/**
+ * This function handles a particular connection when it has been
+ * determined that there is data to be read off a socket. All
+ * implementations (multithreaded, external select, internal select)
+ * call this function to handle reads.
+ * 
+ * @return MHD_YES if we should continue to process the
+ *         connection (not dead yet), MHD_NO if it died
+ */
+int
+MHD_connection_handle_read (struct MHD_Connection *connection)
+{
+  connection->last_activity = time(NULL);
+  if (connection->state == MHD_CONNECTION_CLOSED) 
+    return MHD_NO;
+  if (MHD_NO == do_read(connection))
+    return MHD_YES;
+  while (1) {
+#if DEBUG_STATES
+    fprintf(stderr,
+            "`%s' in state %u\n",
+            __FUNCTION__,
+            connection->state);
+#endif    
+    switch (connection->state)
+      {
+      case MHD_CONNECTION_INIT:
+      case MHD_CONNECTION_URL_RECEIVED:
+      case MHD_CONNECTION_HEADER_PART_RECEIVED:
+      case MHD_CONNECTION_HEADERS_RECEIVED:
+      case MHD_CONNECTION_HEADERS_PROCESSED:
+      case MHD_CONNECTION_CONTINUE_SENDING:
+      case MHD_CONNECTION_CONTINUE_SENT:
+      case MHD_CONNECTION_BODY_RECEIVED:
+      case MHD_CONNECTION_FOOTER_PART_RECEIVED:
+        /* nothing to do but default action */
+        if (MHD_YES == connection->read_closed) 
+          {
+            connection->state = MHD_CONNECTION_CLOSED;
+            continue;
+          }
+        break;
+      case MHD_CONNECTION_CLOSED:
+        if (connection->socket_fd != -1)
+          connection_close_error (connection);
+        return MHD_NO;
+      default:
+        /* shrink read buffer to how much is actually used */
+        MHD_pool_reallocate (connection->pool,
+                             connection->read_buffer,
+                             connection->read_buffer_size + 1,
+                             connection->read_buffer_offset);       
+        break;
+      }
+    break;
+  }
+  return MHD_YES;
+}
+
+/**
+ * Try writing data to the socket from the
+ * write buffer of the connection.
+ *
+ * @return MHD_YES if something changed,
+ *         MHD_NO if we were interrupted 
+ */
+static int
+do_write(struct MHD_Connection * connection)
+{
+  int ret;
+
+  ret = SEND (connection->socket_fd,
+              &connection->write_buffer[connection->
+                                        write_buffer_send_offset],
+              connection->write_buffer_append_offset -
+              connection->write_buffer_send_offset, MSG_NOSIGNAL);
+  if (ret < 0)
+    {
+      if (errno == EINTR)
+        return MHD_NO;
+#if HAVE_MESSAGES
+      MHD_DLOG (connection->daemon,
+                "Failed to send data: %s\n", STRERROR (errno));
+#endif
+      connection_close_error (connection);
+      return MHD_YES;
     }
-  strcpy (&data[off], date);
-  off += strlen (date);
-  sprintf (&data[off], "\r\n");
-  off += 2;
-  if (off != size)
-    abort ();
-  connection->write_buffer = data;
-  connection->write_buffer_append_offset = size;
+#if DEBUG_SEND_DATA
+  fprintf (stderr,
+           "Sent HEADER response: `%.*s'\n",
+           ret,
+           &connection->write_buffer[connection->
+                                     write_buffer_send_offset]);
+#endif
+  connection->write_buffer_send_offset += ret;
+  return MHD_YES;
+}
+
+/**
+ * Check if we are done sending the write-buffer.
+ * If so, transition into "next_state".
+ * @return MHY_NO if we are not done, MHD_YES if we are
+ */
+static int
+check_write_done(struct MHD_Connection * connection,
+                 enum MHD_CONNECTION_STATE next_state)
+{
+  if (connection->write_buffer_append_offset !=
+      connection->write_buffer_send_offset)
+    return MHD_NO;    
+  connection->write_buffer_append_offset = 0;
   connection->write_buffer_send_offset = 0;
-  connection->write_buffer_size = size + 1;
+  connection->state = next_state;
+  MHD_pool_reallocate (connection->pool,
+                       connection->write_buffer,
+                       connection->write_buffer_size, 0);
+  connection->write_buffer = NULL;
+  connection->write_buffer_size = 0;
   return MHD_YES;
 }
 
@@ -1196,207 +1454,414 @@ MHD_build_header_response (struct MHD_Connection *connection)
  * been determined that the socket can be written to. All
  * implementations (multithreaded, external select, internal select)
  * call this function
+ * 
+ * @return MHD_YES if we should continue to process the
+ *         connection (not dead yet), MHD_NO if it died
  */
 int
 MHD_connection_handle_write (struct MHD_Connection *connection)
 {
   struct MHD_Response *response;
   int ret;
-  const char *end;
 
-  if (MHD_need_100_continue (connection))
-    {
-      ret = SEND (connection->socket_fd,
-                  &HTTP_100_CONTINUE[connection->
-                                     continue_message_write_offset],
-                  strlen (HTTP_100_CONTINUE) -
-                  connection->continue_message_write_offset, MSG_NOSIGNAL);
-      if (ret < 0)
-        {
-          if (errno == EINTR)
-            return MHD_YES;
+  connection->last_activity = time(NULL);
+  while (1) {
+#if DEBUG_STATES
+    fprintf(stderr,
+            "`%s' in state %u\n",
+            __FUNCTION__,
+            connection->state);
+#endif    
+    switch (connection->state)
+      {
+      case MHD_CONNECTION_INIT:
+      case MHD_CONNECTION_URL_RECEIVED:
+      case MHD_CONNECTION_HEADER_PART_RECEIVED:
+      case MHD_CONNECTION_HEADERS_RECEIVED:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_HEADERS_PROCESSED:
+        break;
+      case MHD_CONNECTION_CONTINUE_SENDING:
+        ret = SEND (connection->socket_fd,
+                    &HTTP_100_CONTINUE[connection->
+                                       continue_message_write_offset],
+                    strlen (HTTP_100_CONTINUE) -
+                    connection->continue_message_write_offset, MSG_NOSIGNAL);
+        if (ret < 0)
+          {
+            if (errno == EINTR)
+              break;
 #if HAVE_MESSAGES
-          MHD_DLOG (connection->daemon,
-                    "Failed to send data: %s\n", STRERROR (errno));
+            MHD_DLOG (connection->daemon,
+                      "Failed to send data: %s\n", STRERROR (errno));
 #endif
-          connection_close_error (connection);
-          return MHD_YES;
-        }
+            connection_close_error (connection);
+            return MHD_NO;
+          }
 #if DEBUG_SEND_DATA
-      fprintf (stderr,
-               "Sent 100 continue response: `%.*s'\n",
-               ret,
-               &HTTP_100_CONTINUE[connection->continue_message_write_offset]);
+        fprintf (stderr,
+                 "Sent 100 continue response: `%.*s'\n",
+                 ret,
+                 &HTTP_100_CONTINUE[connection->continue_message_write_offset]);
 #endif
-      connection->continue_message_write_offset += ret;
-      return MHD_YES;
-    }
-  response = connection->response;
-  if (response == NULL)
-    {
-#if HAVE_MESSAGES
-      MHD_DLOG (connection->daemon, "Unexpected call to %s.\n", __FUNCTION__);
-#endif
-      return MHD_NO;
-    }
-  if (MHD_NO == connection->have_sent_headers)
-    {
-      if ((connection->write_buffer == NULL) &&
-          (MHD_NO == MHD_build_header_response (connection)))
-        {
-          /* oops - close! */
+        connection->continue_message_write_offset += ret;
+        break;
+      case MHD_CONNECTION_CONTINUE_SENT:
+      case MHD_CONNECTION_BODY_RECEIVED:
+      case MHD_CONNECTION_FOOTER_PART_RECEIVED:
+      case MHD_CONNECTION_FOOTERS_RECEIVED:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_HEADERS_SENDING:
+        do_write(connection);
+        check_write_done(connection,
+                         MHD_CONNECTION_HEADERS_SENT);
+        break;
+      case MHD_CONNECTION_HEADERS_SENT:
+        EXTRA_CHECK(0);
+        break;  
+      case MHD_CONNECTION_NORMAL_BODY_READY:
+        response = connection->response;
+        if (response->crc != NULL)
+          pthread_mutex_lock (&response->mutex);
+        if (MHD_YES != try_ready_normal_body(connection))
+          {
+            if (response->crc != NULL)
+              pthread_mutex_unlock (&response->mutex);
+            connection->state = MHD_CONNECTION_NORMAL_BODY_UNREADY;
+            break;
+          }
+        ret = SEND (connection->socket_fd,
+                    &response->data[connection->response_write_position -
+                                    response->data_start],
+                    response->data_size - (connection->response_write_position -
+                                           response->data_start), MSG_NOSIGNAL);
+#if DEBUG_SEND_DATA
+        if (ret > 0)
+          fprintf (stderr,
+                   "Sent DATA response: `%.*s'\n",
+                   ret,
+                   &response->data[connection->response_write_position -
+                                   response->data_start]);
+#endif  
+        if (response->crc != NULL)
+          pthread_mutex_unlock (&response->mutex);
+        if (ret < 0)
+          {
+            if (errno == EINTR)
+              return MHD_YES;
 #if HAVE_MESSAGES
-          MHD_DLOG (connection->daemon,
-                    "Closing connection (failed to create response header)\n");
+            MHD_DLOG (connection->daemon,
+                      "Failed to send data: %s\n", STRERROR (errno));
 #endif
-          connection_close_error (connection);
-          return MHD_NO;
-        }
-      ret = SEND (connection->socket_fd,
-                  &connection->write_buffer[connection->
-                                            write_buffer_send_offset],
-                  connection->write_buffer_append_offset -
-                  connection->write_buffer_send_offset, MSG_NOSIGNAL);
-      if (ret < 0)
-        {
-          if (errno == EINTR)
-            return MHD_YES;
+            connection_close_error (connection);
+            return MHD_NO;
+          }
+        connection->response_write_position += ret;
+        if (connection->response_write_position == connection->response->total_size)
+          connection->state = MHD_CONNECTION_FOOTERS_SENT; /* have no footers... */
+        break;  
+      case MHD_CONNECTION_NORMAL_BODY_UNREADY:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_CHUNKED_BODY_READY:
+        do_write(connection);
+        check_write_done(connection,
+                         (connection->response->total_size == connection->response_write_position) 
+                         ? MHD_CONNECTION_BODY_SENT
+                         : MHD_CONNECTION_CHUNKED_BODY_UNREADY);
+        break;
+      case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
+      case MHD_CONNECTION_BODY_SENT:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_FOOTERS_SENDING:
+        do_write(connection);
+        check_write_done(connection,
+                         MHD_CONNECTION_FOOTERS_SENT);
+        break;          
+      case MHD_CONNECTION_FOOTERS_SENT:
+        EXTRA_CHECK(0);
+        break;
+      case MHD_CONNECTION_CLOSED:
+        if (connection->socket_fd != -1) 
+          connection_close_error(connection);     
+        return MHD_NO;
+     }
+    break;
+  }
+  return MHD_YES;
+}
+
+/**
+ * This function was created to handle per-connection processing that
+ * has to happen even if the socket cannot be read or written to.  All
+ * implementations (multithreaded, external select, internal select)
+ * call this function.
+ * 
+ * @return MHD_YES if we should continue to process the
+ *         connection (not dead yet), MHD_NO if it died
+ */
+int
+MHD_connection_handle_idle (struct MHD_Connection *connection)
+{
+  unsigned int timeout;
+  const char * end;
+  char * line;
+
+  while (1) {
+#if DEBUG_STATES
+    fprintf(stderr,
+            "`%s' in state %u\n",
+            __FUNCTION__,
+            connection->state);
+#endif    
+    switch (connection->state)
+      {
+      case MHD_CONNECTION_INIT:
+        line = get_next_header_line(connection);
+        if (line == NULL)
+          break;
+        if (MHD_NO == parse_initial_message_line (connection, line))
+          connection->state = MHD_CONNECTION_CLOSED;
+        else
+          connection->state = MHD_CONNECTION_URL_RECEIVED;
+        continue;
+      case MHD_CONNECTION_URL_RECEIVED:
+        line = get_next_header_line(connection);
+        if (line == NULL)
+          break;
+        if (strlen(line) == 0)
+          {
+            connection->state = MHD_CONNECTION_HEADERS_RECEIVED;
+            continue;
+          }
+        process_header_line(connection, line);
+        connection->state = MHD_CONNECTION_HEADER_PART_RECEIVED;
+        continue;
+      case MHD_CONNECTION_HEADER_PART_RECEIVED:
+        line = get_next_header_line(connection);
+        if (line == NULL)
+          break;
+        process_broken_line(connection,
+                            line,
+                            MHD_HEADER_KIND);
+        if (strlen(line) == 0)
+          {
+            connection->state = MHD_CONNECTION_HEADERS_RECEIVED;
+            continue;
+          }
+        continue;
+      case MHD_CONNECTION_HEADERS_RECEIVED:
+        parse_connection_headers (connection);
+        if (connection->state == MHD_CONNECTION_CLOSED)
+          continue;
+        connection->state = MHD_CONNECTION_HEADERS_PROCESSED;
+        continue;
+      case MHD_CONNECTION_HEADERS_PROCESSED:
+        call_connection_handler (connection); /* first call */
+        if (need_100_continue(connection)) 
+          {
+            connection->state = MHD_CONNECTION_CONTINUE_SENDING;
+            break;
+          }
+        connection->state = (connection->remaining_upload_size == 0)
+          ? MHD_CONNECTION_FOOTERS_RECEIVED 
+          : MHD_CONNECTION_CONTINUE_SENT;
+        continue;
+      case MHD_CONNECTION_CONTINUE_SENDING:
+        if (connection->continue_message_write_offset ==
+            strlen (HTTP_100_CONTINUE))
+          {
+            connection->state = MHD_CONNECTION_CONTINUE_SENT;
+            continue;
+          }
+        break;
+      case MHD_CONNECTION_CONTINUE_SENT:
+        if (connection->read_buffer_offset != 0) {
+          call_connection_handler(connection); /* loop call */
+          if (connection->state == MHD_CONNECTION_CLOSED)
+            continue;
+        }
+        if ( (connection->remaining_upload_size == 0) ||
+             ( (connection->remaining_upload_size == -1) &&
+               (connection->read_buffer_offset == 0) &&
+               (MHD_YES == connection->read_closed) ) )
+          {
+            if ( (MHD_YES == connection->have_chunked_upload) &&
+                 (MHD_NO == connection->read_closed) ) 
+              connection->state = MHD_CONNECTION_BODY_RECEIVED;
+            else
+              connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
+            continue;
+          }
+        break;
+      case MHD_CONNECTION_BODY_RECEIVED:
+        line = get_next_header_line(connection);
+        if (line == NULL)
+          break;
+        if (strlen(line) == 0)
+          {
+            connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
+            continue;
+          }
+        process_header_line(connection, line);
+        connection->state = MHD_CONNECTION_FOOTER_PART_RECEIVED;
+        continue;
+      case MHD_CONNECTION_FOOTER_PART_RECEIVED:
+        line = get_next_header_line(connection);
+        if (line == NULL)
+          break;
+        process_broken_line(connection,
+                            line,
+                            MHD_FOOTER_KIND);
+        if (strlen(line) == 0)
+          {
+            connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
+            continue;
+          }
+        continue;
+      case MHD_CONNECTION_FOOTERS_RECEIVED:     
+        call_connection_handler (connection); /* "final" call */
+        if (connection->state == MHD_CONNECTION_CLOSED)
+          continue;
+        if (connection->response == NULL) 
+          break; /* try again next time */        
+        if (MHD_NO == build_header_response (connection))
+          {
+            /* oops - close! */
 #if HAVE_MESSAGES
-          MHD_DLOG (connection->daemon,
-                    "Failed to send data: %s\n", STRERROR (errno));
+            MHD_DLOG (connection->daemon,
+                      "Closing connection (failed to create response header)\n");
 #endif
-          connection_close_error (connection);
-          return MHD_YES;
-        }
-#if DEBUG_SEND_DATA
-      fprintf (stderr,
-               "Sent HEADER response: `%.*s'\n",
-               ret,
-               &connection->write_buffer[connection->
-                                         write_buffer_send_offset]);
-#endif
-      connection->write_buffer_send_offset += ret;
-      if (connection->write_buffer_append_offset ==
-          connection->write_buffer_send_offset)
-        {
-          connection->write_buffer_append_offset = 0;
-          connection->write_buffer_send_offset = 0;
-          connection->have_sent_headers = MHD_YES;
-          MHD_pool_reallocate (connection->pool,
-                               connection->write_buffer,
-                               connection->write_buffer_size, 0);
-          connection->write_buffer = NULL;
-          connection->write_buffer_size = 0;
-        }
-      return MHD_YES;
-    }
-  if (response->total_size < connection->response_write_position)
-    abort ();                   /* internal error */
-  if (response->crc != NULL)
-    pthread_mutex_lock (&response->mutex);
-
-  /* prepare send buffer */
-  if ((response->crc != NULL) &&
-      ((response->data_start > connection->response_write_position) ||
-       (response->data_start + response->data_size <=
-        connection->response_write_position))
-      && (MHD_YES != ready_response (connection)))
-    {
-      pthread_mutex_unlock (&response->mutex);
-      return MHD_YES;
-    }
-  /* transmit */
-  ret = SEND (connection->socket_fd,
-              &response->data[connection->response_write_position -
-                              response->data_start],
-              response->data_size - (connection->response_write_position -
-                                     response->data_start), MSG_NOSIGNAL);
-  if (response->crc != NULL)
-    pthread_mutex_unlock (&response->mutex);
-  if (ret < 0)
+            connection->state = MHD_CONNECTION_CLOSED;
+            continue;           
+          }
+        connection->state = MHD_CONNECTION_HEADERS_SENDING;
+        break;
+      case MHD_CONNECTION_HEADERS_SENDING:
+        /* no default action */
+        break;
+      case MHD_CONNECTION_HEADERS_SENT:
+        if (connection->have_chunked_upload)
+          connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY;
+        else
+          connection->state = MHD_CONNECTION_NORMAL_BODY_UNREADY;
+        continue;
+      case MHD_CONNECTION_NORMAL_BODY_READY:
+        /* nothing to do here */
+        break;
+      case MHD_CONNECTION_NORMAL_BODY_UNREADY:
+        if (connection->response->crc != NULL)
+          pthread_mutex_lock (&connection->response->mutex);
+        if (MHD_YES == try_ready_normal_body(connection))
+          {
+            if (connection->response->crc != NULL)
+              pthread_mutex_unlock (&connection->response->mutex);
+            connection->state = MHD_CONNECTION_NORMAL_BODY_READY;
+            break;
+          }     
+        if (connection->response->crc != NULL)
+          pthread_mutex_unlock (&connection->response->mutex);
+        /* not ready, no socket action */
+        break;
+      case MHD_CONNECTION_CHUNKED_BODY_READY:
+        /* nothing to do here */
+        break;
+      case MHD_CONNECTION_CHUNKED_BODY_UNREADY: 
+        if (connection->response->crc != NULL)
+          pthread_mutex_lock (&connection->response->mutex);
+        if (MHD_YES == try_ready_chunked_body(connection))
+          {
+            if (connection->response->crc != NULL)
+              pthread_mutex_unlock (&connection->response->mutex);
+            connection->state = MHD_CONNECTION_CHUNKED_BODY_READY;
+            continue;
+          }
+        if (connection->response->crc != NULL)
+          pthread_mutex_unlock (&connection->response->mutex);
+        break;
+      case MHD_CONNECTION_BODY_SENT:
+        build_header_response(connection);
+        if (connection->write_buffer_send_offset  == connection->write_buffer_append_offset)
+          connection->state = MHD_CONNECTION_FOOTERS_SENT;
+        else
+          connection->state = MHD_CONNECTION_FOOTERS_SENDING;
+        continue;
+      case MHD_CONNECTION_FOOTERS_SENDING:
+        /* no default action */
+        break;
+      case MHD_CONNECTION_FOOTERS_SENT:
+        MHD_destroy_response (connection->response);
+        if (connection->daemon->notify_completed != NULL)
+          connection->daemon->notify_completed (connection->daemon->
+                                                notify_completed_cls,
+                                                connection,
+                                                &connection->client_context,
+                                                MHD_REQUEST_TERMINATED_COMPLETED_OK);
+        end = MHD_lookup_connection_value (connection,
+                                           MHD_HEADER_KIND,
+                                           MHD_HTTP_HEADER_CONNECTION);
+        connection->client_context = NULL;
+        connection->continue_message_write_offset = 0;
+        connection->responseCode = 0;
+        connection->response = NULL;
+        connection->headers_received = NULL;
+        connection->response_write_position = 0;
+        connection->have_chunked_upload = MHD_NO;
+        connection->method = NULL;
+        connection->url = NULL;
+        connection->write_buffer = NULL;
+        connection->write_buffer_size = 0;
+        connection->write_buffer_send_offset = 0;
+        connection->write_buffer_append_offset = 0;
+        if ((end != NULL) && (0 == strcasecmp (end, "close")))
+          {
+            connection->read_closed = MHD_YES;    
+            connection->read_buffer_offset = 0;
+          }
+        if ( ( (MHD_YES == connection->read_closed) &&
+               (0 == connection->read_buffer_offset) ) ||
+             (connection->version == NULL) ||
+             (0 != strcasecmp (MHD_HTTP_VERSION_1_1, connection->version)) )
+          {
+            connection->state = MHD_CONNECTION_CLOSED;
+            MHD_pool_destroy (connection->pool);
+            connection->pool = NULL; 
+            connection->read_buffer = NULL;
+            connection->read_buffer_size = 0;
+            connection->read_buffer_offset = 0;
+          }
+        else
+          {             
+            connection->version = NULL;
+            connection->state = MHD_CONNECTION_INIT;
+            connection->read_buffer 
+              = MHD_pool_reset(connection->pool,
+                               connection->read_buffer,
+                               connection->read_buffer_size);
+          }
+        continue;
+      case MHD_CONNECTION_CLOSED:
+        if (connection->socket_fd != -1)
+          connection_close_error (connection);
+        break;
+      default:
+        EXTRA_CHECK(0);
+        break;
+      }
+    break;
+  } 
+  timeout = connection->daemon->connection_timeout;
+  if ( (timeout != 0) &&
+       (time(NULL) - timeout > connection->last_activity) )
     {
-      if (errno == EINTR)
-        return MHD_YES;
-#if HAVE_MESSAGES
-      MHD_DLOG (connection->daemon,
-                "Failed to send data: %s\n", STRERROR (errno));
-#endif
       connection_close_error (connection);
-      return MHD_YES;
-    }
-#if DEBUG_SEND_DATA
-  fprintf (stderr,
-           "Sent DATA response: `%.*s'\n",
-           ret,
-           &response->data[connection->response_write_position -
-                           response->data_start]);
-#endif
-  connection->response_write_position += ret;
-  if (connection->response_write_position > response->total_size)
-    abort ();                   /* internal error */
-  if (connection->response_write_position == response->total_size)
-    {
-      if ((connection->have_received_body == MHD_NO) ||
-          (connection->have_received_headers == MHD_NO))
-        abort ();               /* internal error */
-      MHD_destroy_response (response);
-      if (connection->daemon->notify_completed != NULL)
-        connection->daemon->notify_completed (connection->daemon->
-                                              notify_completed_cls,
-                                              connection,
-                                              &connection->client_context,
-                                              MHD_REQUEST_TERMINATED_COMPLETED_OK);
-      end = MHD_lookup_connection_value (connection,
-                                         MHD_HEADER_KIND,
-                                         MHD_HTTP_HEADER_CONNECTION);
-      connection->client_context = NULL;
-      connection->continue_message_write_offset = 0;
-      connection->responseCode = 0;
-      connection->response = NULL;
-      connection->headers_received = NULL;
-      connection->have_received_headers = MHD_NO;
-      connection->have_sent_headers = MHD_NO;
-      connection->have_received_body = MHD_NO;
-      connection->response_write_position = 0;
-      connection->have_chunked_upload = MHD_NO;
-      connection->method = NULL;
-      connection->url = NULL;
-      if ((end != NULL) && (0 == strcasecmp (end, "close")))
-        {
-          /* other side explicitly requested
-             that we close the connection after
-             this request */
-          connection->read_close = MHD_YES;
-        }
-      if ((connection->read_close == MHD_YES) ||
-          (0 != strcasecmp (MHD_HTTP_VERSION_1_1, connection->version)))
-        {
-          /* closed for reading => close for good! */
-          if (connection->socket_fd != -1)
-            {
-#if DEBUG_CLOSE
-#if HAVE_MESSAGES
-              MHD_DLOG (connection->daemon,
-                        "Closing connection (http 1.0 or end-of-stream for unknown content length)\n");
-#endif
-#endif
-              SHUTDOWN (connection->socket_fd, SHUT_RDWR);
-              CLOSE (connection->socket_fd);
-            }
-          connection->socket_fd = -1;
-        }
-      connection->version = NULL;
-      connection->read_buffer = NULL;
-      connection->write_buffer = NULL;
-      connection->read_buffer_size = 0;
-      connection->read_buffer_offset = 0;
-      connection->write_buffer_size = 0;
-      connection->write_buffer_send_offset = 0;
-      connection->write_buffer_append_offset = 0;
-      MHD_pool_destroy (connection->pool);
-      connection->pool = NULL;
+      return MHD_NO;  
     }
   return MHD_YES;
+
 }
 
 /* end of connection.c */
diff --git a/src/daemon/connection.h b/src/daemon/connection.h
index e00a83e1..a1763b55 100644
--- a/src/daemon/connection.h
+++ b/src/daemon/connection.h
@@ -39,18 +39,14 @@ MHD_connection_get_fdset (struct MHD_Connection *connection,
                           fd_set * write_fd_set,
                           fd_set * except_fd_set, int *max_fd);
 
-
-/**
- * Call the handler of the application for this
- * connection.
- */
-void MHD_call_connection_handler (struct MHD_Connection *connection);
-
 /**
  * This function handles a particular connection when it has been
  * determined that there is data to be read off a socket. All implementations
  * (multithreaded, external select, internal select) call this function
  * to handle reads.
+ * 
+ * @return MHD_YES if we should continue to process the
+ *         connection (not dead yet), MHD_NO if it died
  */
 int MHD_connection_handle_read (struct MHD_Connection *connection);
 
@@ -60,8 +56,23 @@ int MHD_connection_handle_read (struct MHD_Connection *connection);
  * determined that the socket can be written to. If there is no data
  * to be written, however, the function call does nothing. All implementations
  * (multithreaded, external select, internal select) call this function
+ * 
+ * @return MHD_YES if we should continue to process the
+ *         connection (not dead yet), MHD_NO if it died
  */
 int MHD_connection_handle_write (struct MHD_Connection *connection);
 
 
+/**
+ * This function was created to handle per-connection processing that
+ * has to happen even if the socket cannot be read or written to.  All
+ * implementations (multithreaded, external select, internal select)
+ * call this function.
+ * 
+ * @return MHD_YES if we should continue to process the
+ *         connection (not dead yet), MHD_NO if it died
+ */
+int
+MHD_connection_handle_idle (struct MHD_Connection *connection);
+  
 #endif
diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index 19c614a1..b6f1e9f3 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -52,85 +52,6 @@
  */
 #define DEBUG_CONNECT MHD_NO
 
-/**
- * Register an access handler for all URIs beginning with uri_prefix.
- *
- * @param uri_prefix
- * @return MRI_NO if a handler for this exact prefix
- *         already exists
- */
-int
-MHD_register_handler (struct MHD_Daemon *daemon,
-                      const char *uri_prefix,
-                      MHD_AccessHandlerCallback dh, void *dh_cls)
-{
-  struct MHD_Access_Handler *ah;
-
-  if ((daemon == NULL) || (uri_prefix == NULL) || (dh == NULL))
-    return MHD_NO;
-  ah = daemon->handlers;
-  while (ah != NULL)
-    {
-      if (0 == strcmp (uri_prefix, ah->uri_prefix))
-        return MHD_NO;
-      ah = ah->next;
-    }
-  ah = malloc (sizeof (struct MHD_Access_Handler));
-  if (ah == NULL)
-    {
-#if HAVE_MESSAGES
-      MHD_DLOG (daemon, "Error allocating memory: %s\n", STRERROR (errno));
-#endif
-      return MHD_NO;
-    }
-
-  ah->next = daemon->handlers;
-  ah->uri_prefix = strdup (uri_prefix);
-  ah->dh = dh;
-  ah->dh_cls = dh_cls;
-  daemon->handlers = ah;
-  return MHD_YES;
-}
-
-
-/**
- * Unregister an access handler for the URIs beginning with
- * uri_prefix.
- *
- * @param uri_prefix
- * @return MHD_NO if a handler for this exact prefix
- *         is not known for this daemon
- */
-int
-MHD_unregister_handler (struct MHD_Daemon *daemon,
-                        const char *uri_prefix,
-                        MHD_AccessHandlerCallback dh, void *dh_cls)
-{
-  struct MHD_Access_Handler *prev;
-  struct MHD_Access_Handler *pos;
-
-  if ((daemon == NULL) || (uri_prefix == NULL) || (dh == NULL))
-    return MHD_NO;
-  pos = daemon->handlers;
-  prev = NULL;
-  while (pos != NULL)
-    {
-      if ((dh == pos->dh) &&
-          (dh_cls == pos->dh_cls) &&
-          (0 == strcmp (uri_prefix, pos->uri_prefix)))
-        {
-          if (prev == NULL)
-            daemon->handlers = pos->next;
-          else
-            prev->next = pos->next;
-          free (pos);
-          return MHD_YES;
-        }
-      prev = pos;
-      pos = pos->next;
-    }
-  return MHD_NO;
-}
 
 /**
  * Obtain the select sets for this daemon.
@@ -175,7 +96,6 @@ MHD_get_fdset (struct MHD_Daemon *daemon,
   return MHD_YES;
 }
 
-
 /**
  * Main function of the thread that handles an individual
  * connection.
@@ -191,26 +111,27 @@ MHD_handle_connection (void *data)
   int max;
   struct timeval tv;
   unsigned int timeout;
-  time_t now;
+  unsigned int now;
 
   if (con == NULL)
     abort ();
   timeout = con->daemon->connection_timeout;
-  now = time (NULL);
-  while ((!con->daemon->shutdown) &&
-         (con->socket_fd != -1) &&
-         ((timeout == 0) || (now - timeout > con->last_activity)))
+  while ( (!con->daemon->shutdown) &&
+          (con->socket_fd != -1) )
     {
       FD_ZERO (&rs);
       FD_ZERO (&ws);
       FD_ZERO (&es);
       max = 0;
       MHD_connection_get_fdset (con, &rs, &ws, &es, &max);
+      now = time(NULL);      
       tv.tv_usec = 0;
-      tv.tv_sec = timeout - (now - con->last_activity);
+      if ( timeout > (now - con->last_activity) )
+        tv.tv_sec = timeout - (now - con->last_activity);
+      else
+        tv.tv_sec = 0;
       num_ready = SELECT (max + 1,
                           &rs, &ws, &es, (timeout != 0) ? &tv : NULL);
-      now = time (NULL);
       if (num_ready < 0)
         {
           if (errno == EINTR)
@@ -221,18 +142,13 @@ MHD_handle_connection (void *data)
 #endif
           break;
         }
-      if (((FD_ISSET (con->socket_fd, &rs)) &&
-           (MHD_YES != MHD_connection_handle_read (con))) ||
-          ((con->socket_fd != -1) &&
-           (FD_ISSET (con->socket_fd, &ws)) &&
-           (MHD_YES != MHD_connection_handle_write (con))))
-        break;
-      if ((con->have_received_headers == MHD_YES) && (con->response == NULL))
-        MHD_call_connection_handler (con);
+      if (FD_ISSET (con->socket_fd, &rs))
+           MHD_connection_handle_read (con);
       if ((con->socket_fd != -1) &&
-          ((FD_ISSET (con->socket_fd, &rs)) ||
-           (FD_ISSET (con->socket_fd, &ws))))
-        con->last_activity = now;
+          (FD_ISSET (con->socket_fd, &ws)) )
+        MHD_connection_handle_write (con);
+      if (con->socket_fd != -1) 
+        MHD_connection_handle_idle (con);
     }
   if (con->socket_fd != -1)
     {
@@ -370,11 +286,6 @@ MHD_accept_connection (struct MHD_Daemon *daemon)
  * Free resources associated with all closed connections.
  * (destroy responses, free buffers, etc.).  A connection
  * is known to be closed if the socket_fd is -1.
- *
- * Also performs connection actions that need to be run
- * even if the connection is not selectable (such as
- * calling the application again with upload data when
- * the upload data buffer is full).
  */
 static void
 MHD_cleanup_connections (struct MHD_Daemon *daemon)
@@ -382,33 +293,11 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
   struct MHD_Connection *pos;
   struct MHD_Connection *prev;
   void *unused;
-  time_t timeout;
 
-  timeout = time (NULL);
-  if (daemon->connection_timeout != 0)
-    timeout -= daemon->connection_timeout;
-  else
-    timeout = 0;
   pos = daemon->connections;
   prev = NULL;
   while (pos != NULL)
     {
-      if ((pos->last_activity < timeout) && (pos->socket_fd != -1))
-        {
-#if DEBUG_CLOSE
-#if HAVE_MESSAGES
-          MHD_DLOG (daemon, "Connection timed out, closing connection\n");
-#endif
-#endif
-          SHUTDOWN (pos->socket_fd, SHUT_RDWR);
-          CLOSE (pos->socket_fd);
-          pos->socket_fd = -1;
-          if (pos->daemon->notify_completed != NULL)
-            pos->daemon->notify_completed (pos->daemon->notify_completed_cls,
-                                           pos,
-                                           &pos->client_context,
-                                           MHD_REQUEST_TERMINATED_TIMEOUT_REACHED);
-        }
       if (pos->socket_fd == -1)
         {
           if (prev == NULL)
@@ -420,8 +309,7 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
               pthread_kill (pos->pid, SIGALRM);
               pthread_join (pos->pid, &unused);
             }
-          if (pos->response != NULL)
-            MHD_destroy_response (pos->response);
+          MHD_destroy_response (pos->response);
           MHD_pool_destroy (pos->pool);
           free (pos->addr);
           free (pos);
@@ -432,12 +320,6 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
             pos = prev->next;
           continue;
         }
-
-      if ((0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
-          ((pos->have_received_headers == MHD_YES)
-           && (pos->response == NULL)))
-        MHD_call_connection_handler (pos);
-
       prev = pos;
       pos = pos->next;
     }
@@ -573,15 +455,12 @@ MHD_select (struct MHD_Daemon *daemon, int may_block)
           if (ds != -1)
             {
               if (FD_ISSET (ds, &rs))
-                {
-                  pos->last_activity = now;
-                  MHD_connection_handle_read (pos);
-                }
-              if (FD_ISSET (ds, &ws))
-                {
-                  pos->last_activity = now;
-                  MHD_connection_handle_write (pos);
-                }
+                MHD_connection_handle_read (pos); 
+              if ( (pos->socket_fd != -1) &&
+                   (FD_ISSET (ds, &ws)) )
+                MHD_connection_handle_write (pos);
+              if (pos->socket_fd != -1)
+                MHD_connection_handle_idle(pos); 
             }
           pos = pos->next;
         }
@@ -726,10 +605,8 @@ MHD_start_daemon (unsigned int options,
   retVal->apc = apc;
   retVal->apc_cls = apc_cls;
   retVal->socket_fd = socket_fd;
-  retVal->default_handler.dh = dh;
-  retVal->default_handler.dh_cls = dh_cls;
-  retVal->default_handler.uri_prefix = "";
-  retVal->default_handler.next = NULL;
+  retVal->default_handler = dh;
+  retVal->default_handler_cls = dh_cls;
   retVal->max_connections = MHD_MAX_CONNECTIONS_DEFAULT;
   retVal->pool_size = MHD_POOL_SIZE_DEFAULT;
   retVal->connection_timeout = 0;       /* no timeout */
diff --git a/src/daemon/daemontest_get.c b/src/daemon/daemontest_get.c
index c6c63fd8..1a6ca12a 100644
--- a/src/daemon/daemontest_get.c
+++ b/src/daemon/daemontest_get.c
@@ -66,16 +66,24 @@ ahc_echo (void *cls,
           const char *upload_data, unsigned int *upload_data_size,
           void **unused)
 {
+  static int ptr;
   const char *me = cls;
   struct MHD_Response *response;
   int ret;
 
   if (0 != strcmp (me, method))
     return MHD_NO;              /* unexpected method */
+  if (&ptr != *unused) {
+    *unused = &ptr;
+    return MHD_YES;
+  }
+  *unused = NULL;
   response = MHD_create_response_from_data (strlen (url),
                                             (void *) url, MHD_NO, MHD_YES);
   ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
   MHD_destroy_response (response);
+  if (ret == MHD_NO)
+    abort();
   return ret;
 }
 
@@ -93,11 +101,11 @@ testInternalGet ()
   cbc.size = 2048;
   cbc.pos = 0;
   d = MHD_start_daemon (MHD_USE_SELECT_INTERNALLY | MHD_USE_DEBUG,
-                        1080, NULL, NULL, &ahc_echo, "GET", MHD_OPTION_END);
+                        11080, NULL, NULL, &ahc_echo, "GET", MHD_OPTION_END);
   if (d == NULL)
     return 1;
   c = curl_easy_init ();
-  curl_easy_setopt (c, CURLOPT_URL, "http://localhost:1080/hello_world");
+  curl_easy_setopt (c, CURLOPT_URL, "http://localhost:11080/hello_world");
   curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, &copyBuffer);
   curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc);
   curl_easy_setopt (c, CURLOPT_FAILONERROR, 1);
@@ -150,12 +158,12 @@ testMultithreadedGet ()
   curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, &copyBuffer);
   curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc);
   curl_easy_setopt (c, CURLOPT_FAILONERROR, 1);
-  curl_easy_setopt (c, CURLOPT_TIMEOUT, 2L);
+  curl_easy_setopt (c, CURLOPT_TIMEOUT, 150L);
   if (oneone)
     curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
   else
     curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
-  curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 2L);
+  curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 15L);
   // NOTE: use of CONNECTTIMEOUT without also
   //   setting NOSIGNAL results in really weird
   //   crashes on my system!
@@ -214,8 +222,8 @@ testExternalGet ()
     curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
   else
     curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
-  curl_easy_setopt (c, CURLOPT_TIMEOUT, 5L);
-  curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 5L);
+  curl_easy_setopt (c, CURLOPT_TIMEOUT, 150L);
+  curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 15L);
   // NOTE: use of CONNECTTIMEOUT without also
   //   setting NOSIGNAL results in really weird
   //   crashes on my system!
diff --git a/src/daemon/daemontest_large_put.c b/src/daemon/daemontest_large_put.c
index 2a9ad4fa..3bbf707e 100644
--- a/src/daemon/daemontest_large_put.c
+++ b/src/daemon/daemontest_large_put.c
@@ -96,8 +96,16 @@ ahc_echo (void *cls,
     return MHD_NO;              /* unexpected method */
   if ((*done) == 0)
     {
-      if (*upload_data_size != PUT_SIZE)
-        return MHD_YES;         /* not yet ready */
+      if (*upload_data_size != PUT_SIZE) 
+        {
+#if 0
+          fprintf(stderr,
+                  "Waiting for more data (%u/%u)...\n",
+                  *upload_data_size,
+                  PUT_SIZE);
+#endif
+          return MHD_YES;         /* not yet ready */
+        }
       if (0 == memcmp (upload_data, put_buffer, PUT_SIZE))
         {
           *upload_data_size = 0;
@@ -227,7 +235,13 @@ testMultithreadedPut ()
   curl_easy_cleanup (c);
   MHD_stop_daemon (d);
   if (cbc.pos != strlen ("/hello_world"))
-    return 64;
+    {
+      fprintf(stderr,
+              "Got invalid response `%.*s'\n",
+              cbc.pos,
+              cbc.buf);
+      return 64;
+    }
   if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
     return 128;
   return 0;
@@ -260,7 +274,10 @@ testExternalPut ()
   multi = NULL;
   d = MHD_start_daemon (MHD_USE_DEBUG,
                         1082,
-                        NULL, NULL, &ahc_echo, &done_flag, MHD_OPTION_END);
+                        NULL, NULL, &ahc_echo, &done_flag, 
+                        MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                        PUT_SIZE * 4,
+                        MHD_OPTION_END);
   if (d == NULL)
     return 256;
   c = curl_easy_init ();
@@ -357,9 +374,15 @@ testExternalPut ()
     }
   MHD_stop_daemon (d);
   if (cbc.pos != strlen ("/hello_world"))
-    return 64;
+    {
+      fprintf(stderr,
+              "Got invalid response `%.*s'\n",
+              cbc.pos,
+              cbc.buf);
+      return 8192;
+    }
   if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
-    return 128;
+    return 16384;
   return 0;
 }
 
@@ -380,7 +403,7 @@ main (int argc, char *const *argv)
       errorCount += testInternalPut ();
       errorCount += testMultithreadedPut ();
     }
-  errorCount += testExternalPut ();
+  errorCount += testExternalPut (); 
   free (put_buffer);
   if (errorCount != 0)
     fprintf (stderr, "Error (code: %u)\n", errorCount);
diff --git a/src/daemon/daemontest_postform.c b/src/daemon/daemontest_postform.c
index 75df1eb0..00734df6 100644
--- a/src/daemon/daemontest_postform.c
+++ b/src/daemon/daemontest_postform.c
@@ -72,6 +72,13 @@ post_iterator (void *cls,
 {
   int *eok = cls;
 
+#if 0
+  fprintf(stderr,
+          "PI sees %s-%.*s\n",
+          key,
+          size,
+          value);
+#endif
   if ((0 == strcmp (key, "name")) &&
       (size == strlen ("daniel")) && (0 == strncmp (value, "daniel", size)))
     (*eok) |= 1;
@@ -95,7 +102,7 @@ ahc_echo (void *cls,
   struct MHD_PostProcessor *pp;
   int ret;
 
-  if (0 != strcmp ("POST", method))
+  if (0 != strcmp ("POST", method)) 
     {
       printf ("METHOD: %s\n", method);
       return MHD_NO;            /* unexpected method */
diff --git a/src/daemon/daemontest_put_chunked.c b/src/daemon/daemontest_put_chunked.c
index 9f00dbb3..84afc444 100644
--- a/src/daemon/daemontest_put_chunked.c
+++ b/src/daemon/daemontest_put_chunked.c
@@ -105,6 +105,11 @@ ahc_echo (void *cls,
           printf ("Invalid upload data `%8s'!\n", upload_data);
           return MHD_NO;
         }
+#if 0
+      fprintf(stderr,
+              "Not ready for response: %u/%u\n",
+              *done, 8);
+#endif
       return MHD_YES;
     }
   response = MHD_create_response_from_data (strlen (url),
diff --git a/src/daemon/fileserver_example.c b/src/daemon/fileserver_example.c
index c5bf762b..9f86fd2c 100644
--- a/src/daemon/fileserver_example.c
+++ b/src/daemon/fileserver_example.c
@@ -52,8 +52,9 @@ ahc_echo (void *cls,
           const char *url,
           const char *method,
           const char *upload_data,
-          const char *version, unsigned int *upload_data_size, void **unused)
+          const char *version, unsigned int *upload_data_size, void **ptr)
 {
+  static int aptr;
   struct MHD_Response *response;
   int ret;
   FILE *file;
@@ -61,6 +62,13 @@ ahc_echo (void *cls,
 
   if (0 != strcmp (method, "GET"))
     return MHD_NO;              /* unexpected method */
+   if (&aptr != *ptr) 
+    {
+      /* do never respond on first call */
+      *ptr = &aptr;
+      return MHD_YES;
+    }
+  *ptr = NULL; /* reset when done */
   file = fopen (&url[1], "r");
   if (file == NULL)
     {
diff --git a/src/daemon/internal.h b/src/daemon/internal.h
index de4ae725..4749d10d 100644
--- a/src/daemon/internal.h
+++ b/src/daemon/internal.h
@@ -85,21 +85,9 @@ struct MHD_HTTP_Header
   char *value;
 
   enum MHD_ValueKind kind;
-};
-
-
-struct MHD_Access_Handler
-{
-  struct MHD_Access_Handler *next;
-
-  char *uri_prefix;
-
-  MHD_AccessHandlerCallback dh;
 
-  void *dh_cls;
 };
 
-
 /**
  * Representation of a response.
  */
@@ -172,7 +160,129 @@ struct MHD_Response
 
 };
 
+/**
+ * States in a state machine for a connection.
+ *
+ * Transitions are any-state to CLOSED, any state to state+1,
+ * FOOTERS_SENT to INIT.  CLOSED is the terminal state and
+ * INIT the initial state.
+ *
+ * Note that transitions for *reading* happen only after
+ * the input has been processed; transitions for
+ * *writing* happen after the respective data has been
+ * put into the write buffer (the write does not have
+ * to be completed yet).  A transition to CLOSED or INIT
+ * requires the write to be complete.
+ */
+enum MHD_CONNECTION_STATE
+{
+  /**
+   * Connection just started (no headers received).
+   * Waiting for the line with the request type, URL and version.
+   */
+  MHD_CONNECTION_INIT = 0,
+
+  /**
+   * 1: We got the URL (and request type and version).  Wait for a header line.
+   */
+  MHD_CONNECTION_URL_RECEIVED = MHD_CONNECTION_INIT + 1,
+
+  /**
+   * 2: We got part of a multi-line request header.  Wait for the rest.
+   */
+  MHD_CONNECTION_HEADER_PART_RECEIVED = MHD_CONNECTION_URL_RECEIVED + 1,
+
+  /**
+   * 3: We got the request headers.  Process them.
+   */
+  MHD_CONNECTION_HEADERS_RECEIVED = MHD_CONNECTION_HEADER_PART_RECEIVED + 1,
+
+  /**
+   * 4: We have processed the request headers.  Send 100 continue.
+   */
+  MHD_CONNECTION_HEADERS_PROCESSED = MHD_CONNECTION_HEADERS_RECEIVED + 1,
+
+  /**
+   * 5: We have processed the headers and need to send 100 CONTINUE.
+   */
+  MHD_CONNECTION_CONTINUE_SENDING = MHD_CONNECTION_HEADERS_PROCESSED + 1,
+
+  /**
+   * 6: We have sent 100 CONTINUE (or do not need to).  Read the message body.
+   */
+  MHD_CONNECTION_CONTINUE_SENT = MHD_CONNECTION_CONTINUE_SENDING + 1,
+
+  /**
+   * 7: We got the request body.  Wait for a line of the footer.
+   */
+  MHD_CONNECTION_BODY_RECEIVED = MHD_CONNECTION_CONTINUE_SENT + 1,
 
+  /**
+   * 8: We got part of a line of the footer.  Wait for the
+   * rest.
+   */
+  MHD_CONNECTION_FOOTER_PART_RECEIVED = MHD_CONNECTION_BODY_RECEIVED + 1,
+
+  /**
+   * 9: We received the entire footer.  Wait for a response to be queued
+   * and prepare the response headers.
+   */
+  MHD_CONNECTION_FOOTERS_RECEIVED = MHD_CONNECTION_FOOTER_PART_RECEIVED + 1,
+
+  /**
+   * 10: We have prepared the response headers in the writ buffer.
+   * Send the response headers.
+   */
+  MHD_CONNECTION_HEADERS_SENDING = MHD_CONNECTION_FOOTERS_RECEIVED + 1,
+
+  /**
+   * 11: We have sent the response headers.  Get ready to send the body.
+   */
+  MHD_CONNECTION_HEADERS_SENT = MHD_CONNECTION_HEADERS_SENDING + 1,
+  
+  /**
+   * 12: We are ready to send a part of a non-chunked body.  Send it.
+   */
+  MHD_CONNECTION_NORMAL_BODY_READY = MHD_CONNECTION_HEADERS_SENT + 1,
+  
+  /**
+   * 13: We are waiting for the client to provide more
+   * data of a non-chunked body.
+   */
+  MHD_CONNECTION_NORMAL_BODY_UNREADY = MHD_CONNECTION_NORMAL_BODY_READY + 1,
+
+  /**
+   * 14: We are ready to send a chunk.
+   */
+  MHD_CONNECTION_CHUNKED_BODY_READY = MHD_CONNECTION_NORMAL_BODY_UNREADY + 1,
+
+  /**
+   * 15: We are waiting for the client to provide a chunk of the body.
+   */
+  MHD_CONNECTION_CHUNKED_BODY_UNREADY = MHD_CONNECTION_CHUNKED_BODY_READY + 1,
+  
+  /**
+   * 16: We have sent the response body. Prepare the footers.
+   */
+  MHD_CONNECTION_BODY_SENT = MHD_CONNECTION_CHUNKED_BODY_UNREADY + 1,
+  
+  /**
+   * 17: We have prepared the response footer.  Send it.
+   */
+  MHD_CONNECTION_FOOTERS_SENDING = MHD_CONNECTION_BODY_SENT + 1,  
+
+  /**
+   * 18: We have sent the response footer.  Shutdown or restart.
+   */
+  MHD_CONNECTION_FOOTERS_SENT = MHD_CONNECTION_FOOTERS_SENDING + 1,
+
+  /**
+   * 19: This connection is closed (no more activity
+   * allowed).
+   */
+  MHD_CONNECTION_CLOSED = MHD_CONNECTION_FOOTERS_SENT + 1,
+  
+};
 
 struct MHD_Connection
 {
@@ -250,6 +360,21 @@ struct MHD_Connection
   char *write_buffer;
 
   /**
+   * Last incomplete header line during parsing of headers.
+   * Allocated in pool.  Only valid if state is
+   * either HEADER_PART_RECEIVED or FOOTER_PART_RECEIVED.
+   */
+  char *last;
+
+  /**
+   * Position after the colon on the last incomplete header 
+   * line during parsing of headers.
+   * Allocated in pool.  Only valid if state is
+   * either HEADER_PART_RECEIVED or FOOTER_PART_RECEIVED.
+   */
+  char *colon;
+
+  /**
    * Foreign address (of length addr_len).  MALLOCED (not
    * in pool!).
    */
@@ -292,6 +417,12 @@ struct MHD_Connection
   size_t write_buffer_append_offset;
 
   /**
+   * How many more bytes of the body do we expect
+   * to read? "-1" for unknown.
+   */ 
+  size_t remaining_upload_size;
+
+  /**
    * Current write position in the actual response
    * (excluding headers, content only; should be 0
    * while sending headers).
@@ -299,13 +430,6 @@ struct MHD_Connection
   size_t response_write_position;
 
   /**
-   * Remaining (!) number of bytes in the upload.
-   * Set to -1 for unknown (connection will close
-   * to indicate end of upload).
-   */
-  size_t remaining_upload_size;
-
-  /**
    * Position in the 100 CONTINUE message that
    * we need to send when receiving http 1.1 requests.
    */
@@ -333,29 +457,15 @@ struct MHD_Connection
    * Has this socket been closed for reading (i.e.
    * other side closed the connection)?  If so,
    * we must completely close the connection once
-   * we are done sending our response.
-   */
-  int read_close;
-
-  /**
-   * Have we finished receiving all of the headers yet?
-   * Set to 1 once we are done processing all of the
-   * headers.  Note that due to pipelining, it is
-   * possible that the NEXT request is already
-   * (partially) waiting in the read buffer.
-   */
-  int have_received_headers;
-
-  /**
-   * Have we finished receiving the data from a
-   * potential file-upload?
+   * we are done sending our response (and stop
+   * trying to read from this socket).
    */
-  int have_received_body;
+  int read_closed;
 
   /**
-   * Have we finished sending all of the headers yet?
+   * State in the FSM for this connection.
    */
-  int have_sent_headers;
+  enum MHD_CONNECTION_STATE state;
 
   /**
    * HTTP response code.  Only valid if response object
@@ -373,6 +483,11 @@ struct MHD_Connection
   int response_unready;
 
   /**
+   * Are we sending with chunked encoding?
+   */
+  int have_chunked_response;
+
+  /**
    * Are we receiving with chunked encoding?  This will be set to
    * MHD_YES after we parse the headers and are processing the body
    * with chunks.  After we are done with the body and we are
@@ -402,9 +517,15 @@ struct MHD_Connection
 struct MHD_Daemon
 {
 
-  struct MHD_Access_Handler *handlers;
+  /**
+   * Callback function for all requests.
+   */
+  MHD_AccessHandlerCallback default_handler;
 
-  struct MHD_Access_Handler default_handler;
+  /**
+   * Closure argument to default_handler.
+   */
+  void * default_handler_cls;
 
   /**
    * Linked list of our current connections.
diff --git a/src/daemon/memorypool.c b/src/daemon/memorypool.c
index 6310d7d7..1bb12bae 100644
--- a/src/daemon/memorypool.c
+++ b/src/daemon/memorypool.c
@@ -188,4 +188,33 @@ MHD_pool_reallocate (struct MemoryPool *pool,
   return NULL;
 }
 
+/**
+ * Clear all entries from the memory pool except
+ * for "keep" of the given "size".
+ * 
+ * @param keep pointer to the entry to keep (maybe NULL)
+ * @param size how many bytes need to be kept at this address
+ * @return addr new address of "keep" (if it had to change)
+ */
+void *MHD_pool_reset(struct MemoryPool * pool,
+                     void * keep,
+                     unsigned int size) 
+{
+  if (keep != NULL)
+    {
+      if (keep != pool->memory)
+        {
+          memmove(pool->memory,
+                  keep,
+                  size);
+          keep = pool->memory;
+        }
+      pool->pos = size;
+    }
+  pool->end = pool->size;
+  return keep;
+}
+
+
+
 /* end of memorypool.c */
diff --git a/src/daemon/memorypool.h b/src/daemon/memorypool.h
index 7f53cba5..1d8ffb32 100644
--- a/src/daemon/memorypool.h
+++ b/src/daemon/memorypool.h
@@ -81,4 +81,16 @@ void *MHD_pool_reallocate (struct MemoryPool *pool,
                            void *old,
                            unsigned int old_size, unsigned int new_size);
 
+/**
+ * Clear all entries from the memory pool except
+ * for "keep" of the given "size".
+ * 
+ * @param keep pointer to the entry to keep (maybe NULL)
+ * @param size how many bytes need to be kept at this address
+ * @return addr new address of "keep" (if it had to change)
+ */
+void *MHD_pool_reset(struct MemoryPool * pool,
+                     void * keep,
+                     unsigned int size);
+
 #endif
diff --git a/src/daemon/minimal_example.c b/src/daemon/minimal_example.c
index 62ee5ae5..badff7a2 100644
--- a/src/daemon/minimal_example.c
+++ b/src/daemon/minimal_example.c
@@ -41,14 +41,22 @@ ahc_echo (void *cls,
           const char *url,
           const char *method,
           const char *upload_data,
-          const char *version, unsigned int *upload_data_size, void **unused)
+          const char *version, unsigned int *upload_data_size, void **ptr)
 {
+  static int aptr;
   const char *me = cls;
   struct MHD_Response *response;
   int ret;
 
   if (0 != strcmp (method, "GET"))
     return MHD_NO;              /* unexpected method */
+  if (&aptr != *ptr) 
+    {
+      /* do never respond on first call */
+      *ptr = &aptr;
+      return MHD_YES;
+    }
+  *ptr = NULL; /* reset when done */
   response = MHD_create_response_from_data (strlen (me),
                                             (void *) me, MHD_NO, MHD_NO);
   ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
diff --git a/src/include/microhttpd.h b/src/include/microhttpd.h
index 680e6d23..2197d9d9 100644
--- a/src/include/microhttpd.h
+++ b/src/include/microhttpd.h
@@ -84,7 +84,7 @@ extern "C"
 /**
  * Current version of the library.
  */
-#define MHD_VERSION 0x00000100
+#define MHD_VERSION 0x00000200
 
 /**
  * MHD-internal return codes.
@@ -373,6 +373,11 @@ enum MHD_ValueKind
    */
   MHD_GET_ARGUMENT_KIND = 8,
 
+  /**
+   * HTTP footer (only for http 1.1 chunked encodings).
+   */
+  MHD_FOOTER_KIND = 16,
+
 };
 
 /**
@@ -544,9 +549,15 @@ typedef int
  *        libmicrohttpd guarantees that "pos" will be
  *        the sum of all non-negative return values
  *        obtained from the content reader so far.
- * @return -1 on error (libmicrohttpd will no longer
- *  try to read content and instead close the connection
- *  with the client).
+ * @return -1 for the end of transmission (or on error);
+ *  if a content transfer size was pre-set and the callback
+ *  has provided fewer than that amount of data, 
+ *  MHD will close the connection with the client;
+ *  if no content size was specified and this is an
+ *  http 1.1 connection using chunked encoding, MHD will 
+ *  interpret "-1" as the normal end of the transfer
+ *  (possibly allowing the client to perform additional
+ *  requests using the same TCP connection).
  */
 typedef int
   (*MHD_ContentReaderCallback) (void *cls, size_t pos, char *buf, int max);
@@ -596,7 +607,7 @@ typedef int
  *        in which case connections from any IP will be
  *        accepted
  * @param apc_cls extra argument to apc
- * @param dh default handler for all URIs
+ * @param dh handler called for all requests (repeatedly)
  * @param dh_cls extra argument to dh
  * @param ... list of options (type-value pairs,
  *        terminated with MHD_OPTION_END).
@@ -655,32 +666,6 @@ int MHD_get_timeout (struct MHD_Daemon *daemon, unsigned long long *timeout);
  */
 int MHD_run (struct MHD_Daemon *daemon);
 
-
-/**
- * Register an access handler for all URIs beginning with uri_prefix.
- *
- * @param uri_prefix
- * @return MRI_NO if a handler for this exact prefix
- *         already exists
- */
-int
-MHD_register_handler (struct MHD_Daemon *daemon,
-                      const char *uri_prefix,
-                      MHD_AccessHandlerCallback dh, void *dh_cls);
-
-/**
- * Unregister an access handler for the URIs beginning with
- * uri_prefix.
- *
- * @param uri_prefix
- * @return MHD_NO if a handler for this exact prefix
- *         is not known for this daemon
- */
-int
-MHD_unregister_handler (struct MHD_Daemon *daemon,
-                        const char *uri_prefix,
-                        MHD_AccessHandlerCallback dh, void *dh_cls);
-
 /**
  * Get all of the headers from the request.
  *