adding testcases for PUT and POST

6 files changed, 880 insertions, 10 deletions

diff --git a/src/daemon/Makefile.am b/src/daemon/Makefile.am
index 048c3176..7eda834b 100644
--- a/src/daemon/Makefile.am
+++ b/src/daemon/Makefile.am
@@ -32,7 +32,9 @@ if HAVE_CURL
 
 check_PROGRAMS = \
   daemontest \
-  daemontest1
+  daemontest1 \
+  daemontest_post \
+  daemontest_put
 
 TESTS = $(check_PROGRAMS)
 
@@ -47,4 +49,18 @@ daemontest1_LDADD = \
   $(top_builddir)/src/daemon/libmicrohttpd.la \
   @LIBCURL@ 
 
+
+daemontest_post_SOURCES = \
+  daemontest_post.c
+daemontest_post_LDADD = \
+  $(top_builddir)/src/daemon/libmicrohttpd.la \
+  @LIBCURL@ 
+
+
+daemontest_put_SOURCES = \
+  daemontest_put.c
+daemontest_put_LDADD = \
+  $(top_builddir)/src/daemon/libmicrohttpd.la \
+  @LIBCURL@ 
+
 endif
\ No newline at end of file
diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index 07f1ae71..f393355b 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -317,7 +317,7 @@ MHD_cleanup_sessions(struct MHD_Daemon * daemon) {
     } 
 
     if ( (pos->headersReceived == 1) &&
-         (pos->readLoc > 0) )
+         (pos->response == NULL) )
       MHD_call_session_handler(pos);
     
     prev = pos;
@@ -390,8 +390,10 @@ MHD_select(struct MHD_Daemon * daemon,
     pos = daemon->connections;
     while (pos != NULL) {
       ds = pos->socket_fd;
-      if (ds == -1)
+      if (ds == -1) {
+        pos = pos->next;
         continue;
+      }
       if (FD_ISSET(ds, &rs)) 
         MHD_session_handle_read(pos);
       if (FD_ISSET(ds, &ws))
diff --git a/src/daemon/daemontest1.c b/src/daemon/daemontest1.c
index 354da630..d3b6c5bc 100644
--- a/src/daemon/daemontest1.c
+++ b/src/daemon/daemontest1.c
@@ -21,7 +21,7 @@
 /**
  * @file daemontest1.c
  * @brief  Testcase for libmicrohttpd GET operations
- *         TODO: external select, parsing of query
+ *         TODO: test parsing of query
  * @author Christian Grothoff
  */
 
diff --git a/src/daemon/daemontest_post.c b/src/daemon/daemontest_post.c
new file mode 100644
index 00000000..5e46bac3
--- /dev/null
+++ b/src/daemon/daemontest_post.c
@@ -0,0 +1,399 @@
+/*
+     This file is part of libmicrohttpd
+     (C) 2007 Christian Grothoff
+
+     libmicrohttpd is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     libmicrohttpd is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with libmicrohttpd; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file daemontest_post.c
+ * @brief  Testcase for libmicrohttpd POST operations
+ *         TODO: use curl_formadd to produce POST data and 
+ *               add that to the CURL operation; then check
+ *               on the server side if the headers arrive
+ *               nicely (need to implement parsing POST data
+ *               first!)
+ * @author Christian Grothoff
+ */
+
+#include "config.h"
+#include <curl/curl.h>
+#include <microhttpd.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+
+static int apc_all(void * cls,
+                   const struct sockaddr * addr,
+                   socklen_t addrlen) {
+  return MHD_YES;
+}
+
+struct CBC {
+  char * buf;
+  size_t pos;
+  size_t size;
+};
+
+static size_t copyBuffer(void * ptr,
+                         size_t size,
+                         size_t nmemb,
+                         void * ctx) {
+  struct CBC * cbc = ctx;
+
+  if (cbc->pos + size * nmemb > cbc->size)
+    return 0; /* overflow */
+  memcpy(&cbc->buf[cbc->pos],
+         ptr,
+         size * nmemb);
+  cbc->pos += size * nmemb;
+  return size * nmemb;
+}
+
+static int ahc_echo(void * cls,
+                    struct MHD_Session * session,
+                    const char * url,
+                    const char * method,
+                    const char * upload_data,
+                    unsigned int * upload_data_size) {
+  struct MHD_Response * response;
+  int ret;
+
+  if (0 != strcmp("POST", method)) {
+    printf("METHOD: %s\n", method);
+    return MHD_NO; /* unexpected method */
+  }
+  /* FIXME: check session headers... */
+  response = MHD_create_response_from_data(strlen(url),
+                                           (void*) url,
+                                           MHD_NO,
+                                           MHD_YES);
+  ret = MHD_queue_response(session,
+                           MHD_HTTP_OK,
+                           response);
+  MHD_destroy_response(response);
+  return ret;
+}
+
+
+static int testInternalPost() {
+  struct MHD_Daemon * d;
+  CURL * c;
+  char buf[2048];
+  struct CBC cbc;
+
+  cbc.buf = buf;
+  cbc.size = 2048;
+  cbc.pos = 0;
+  d = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY | MHD_USE_IPv4 | MHD_USE_DEBUG,
+                       1080,
+                       &apc_all,
+                       NULL,
+                       &ahc_echo,
+                       NULL);
+  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_WRITEFUNCTION,
+                   &copyBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEDATA,
+                   &cbc);
+  curl_easy_setopt(c,
+                   CURLOPT_HTTPPOST,
+                   NULL); /* FIXME! */
+  curl_easy_setopt(c,
+                   CURLOPT_POST,
+                   1L);
+  curl_easy_setopt(c,
+                   CURLOPT_FAILONERROR,
+                   1);
+  curl_easy_setopt(c,
+                   CURLOPT_TIMEOUT,
+                   2L);
+  curl_easy_setopt(c,
+                   CURLOPT_CONNECTTIMEOUT,
+                   2L);
+  // NOTE: use of CONNECTTIMEOUT without also
+  //   setting NOSIGNAL results in really weird
+  //   crashes on my system!
+  curl_easy_setopt(c,
+                   CURLOPT_NOSIGNAL,
+                   1);  
+  if (CURLE_OK != curl_easy_perform(c)) {
+    curl_easy_cleanup(c);  
+    MHD_stop_daemon(d);  
+    return 2;
+  }    
+  curl_easy_cleanup(c);  
+  if (cbc.pos != strlen("/hello_world")) {
+    MHD_stop_daemon(d);
+    return 4;
+  }
+  
+  if (0 != strncmp("/hello_world",
+                   cbc.buf,
+                   strlen("/hello_world"))) {
+    MHD_stop_daemon(d);
+    return 8;
+  }
+  MHD_stop_daemon(d);
+  
+  return 0;
+}
+
+static int testMultithreadedPost() {
+  struct MHD_Daemon * d;
+  CURL * c;
+  char buf[2048];
+  struct CBC cbc;
+
+  cbc.buf = buf;
+  cbc.size = 2048;
+  cbc.pos = 0;
+  d = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_IPv4 | MHD_USE_DEBUG,
+                       1081,
+                       &apc_all,
+                       NULL,
+                       &ahc_echo,
+                       NULL);
+  if (d == NULL)
+    return 16;
+  c = curl_easy_init();
+  curl_easy_setopt(c,
+                   CURLOPT_URL,
+                   "http://localhost:1081/hello_world");
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEFUNCTION,
+                   &copyBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEDATA,
+                   &cbc);
+  curl_easy_setopt(c,
+                   CURLOPT_HTTPPOST,
+                   NULL); /* FIXME! */
+  curl_easy_setopt(c,
+                   CURLOPT_POST,
+                   1L);
+  curl_easy_setopt(c,
+                   CURLOPT_FAILONERROR,
+                   1);
+  curl_easy_setopt(c,
+                   CURLOPT_TIMEOUT,
+                   2L);
+  curl_easy_setopt(c,
+                   CURLOPT_CONNECTTIMEOUT,
+                   2L);
+  // NOTE: use of CONNECTTIMEOUT without also
+  //   setting NOSIGNAL results in really weird
+  //   crashes on my system!
+  curl_easy_setopt(c,
+                   CURLOPT_NOSIGNAL,
+                   1);  
+  if (CURLE_OK != curl_easy_perform(c)) {
+    curl_easy_cleanup(c);
+    MHD_stop_daemon(d);  
+    return 32;
+  }
+  curl_easy_cleanup(c);
+  if (cbc.pos != strlen("/hello_world")) {
+    MHD_stop_daemon(d);  
+    return 64;
+  }  
+  if (0 != strncmp("/hello_world",
+                   cbc.buf,
+                   strlen("/hello_world"))) {
+    MHD_stop_daemon(d);
+    return 128;
+  }
+  MHD_stop_daemon(d);
+  
+  return 0;
+}
+
+
+static int testExternalPost() {
+  struct MHD_Daemon * d;
+  CURL * c;
+  char buf[2048];
+  struct CBC cbc;
+  CURLM * multi;
+  CURLMcode mret;
+  fd_set rs;
+  fd_set ws;
+  fd_set es;
+  int max;
+  int running;
+  struct CURLMsg * msg;
+  time_t start;
+  struct timeval tv;
+
+  multi = NULL;
+  cbc.buf = buf;
+  cbc.size = 2048;
+  cbc.pos = 0;
+  d = MHD_start_daemon(MHD_USE_IPv4 | MHD_USE_DEBUG,
+                       1082,
+                       &apc_all,
+                       NULL,
+                       &ahc_echo,
+                       NULL);
+  if (d == NULL)
+    return 256;
+  c = curl_easy_init();
+  curl_easy_setopt(c,
+                   CURLOPT_URL,
+                   "http://localhost:1082/hello_world");
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEFUNCTION,
+                   &copyBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEDATA,
+                   &cbc);
+  curl_easy_setopt(c,
+                   CURLOPT_HTTPPOST,
+                   NULL); /* FIXME! */
+  curl_easy_setopt(c,
+                   CURLOPT_POST,
+                   1L);
+  curl_easy_setopt(c,
+                   CURLOPT_FAILONERROR,
+                   1);
+  curl_easy_setopt(c,
+                   CURLOPT_TIMEOUT,
+                   5L);
+  curl_easy_setopt(c,
+                   CURLOPT_CONNECTTIMEOUT,
+                   5L);
+  // NOTE: use of CONNECTTIMEOUT without also
+  //   setting NOSIGNAL results in really weird
+  //   crashes on my system!
+  curl_easy_setopt(c,
+                   CURLOPT_NOSIGNAL,
+                   1);  
+
+
+  multi = curl_multi_init();
+  if (multi == NULL) {
+    curl_easy_cleanup(c);  
+    MHD_stop_daemon(d);  
+    return 512;
+  }
+  mret = curl_multi_add_handle(multi, c);
+  if (mret != CURLM_OK) {
+    curl_multi_cleanup(multi);
+    curl_easy_cleanup(c);  
+    MHD_stop_daemon(d);  
+    return 1024;
+  }
+  start = time(NULL);
+  while ( (time(NULL) - start < 5) &&
+          (multi != NULL) ) {
+    max = 0;
+    FD_ZERO(&rs);
+    FD_ZERO(&ws);
+    FD_ZERO(&es);
+    curl_multi_perform(multi, &running);
+    mret = curl_multi_fdset(multi,
+                            &rs,
+                            &ws,
+                            &es,
+                            &max);
+    if (mret != CURLM_OK) {
+      curl_multi_remove_handle(multi, c);
+      curl_multi_cleanup(multi);
+      curl_easy_cleanup(c);  
+      MHD_stop_daemon(d);  
+      return 2048;    
+    }
+    if (MHD_YES != MHD_get_fdset(d,
+                                 &rs,
+                                 &ws,
+                                 &es,
+                                 &max)) {
+      curl_multi_remove_handle(multi, c);
+      curl_multi_cleanup(multi);
+      curl_easy_cleanup(c);        
+      MHD_stop_daemon(d);  
+      return 4096;
+    }
+    tv.tv_sec = 0;
+    tv.tv_usec = 1000;
+    select(max + 1,
+           &rs,
+           &ws,
+           &es,
+           &tv);  
+    curl_multi_perform(multi, &running);
+    if (running == 0) {
+      msg = curl_multi_info_read(multi,
+                                 &running);
+      if (msg == NULL)
+        break;
+      if (msg->msg == CURLMSG_DONE) {
+        if (msg->data.result != CURLE_OK)
+          printf("%s failed at %s:%d: `%s'\n",
+                 "curl_multi_perform",
+                 __FILE__,
+                 __LINE__,
+                 curl_easy_strerror(msg->data.result));
+        curl_multi_remove_handle(multi, c);
+        curl_multi_cleanup(multi);
+        curl_easy_cleanup(c);
+        c = NULL;
+        multi = NULL;
+      }
+    }   
+    MHD_run(d);
+  }
+  if (multi != NULL) {
+    curl_multi_remove_handle(multi, c);
+    curl_easy_cleanup(c);  
+    curl_multi_cleanup(multi);
+  }
+  MHD_stop_daemon(d);
+  if (cbc.pos != strlen("/hello_world")) 
+    return 8192;
+  if (0 != strncmp("/hello_world",
+                   cbc.buf,
+                   strlen("/hello_world"))) 
+    return 16384;
+  return 0;
+}
+
+
+
+int main(int argc,
+         char * const * argv) {
+  unsigned int errorCount = 0;
+
+  if (0 != curl_global_init(CURL_GLOBAL_WIN32)) 
+    return 2;  
+  errorCount += testInternalPost();
+  errorCount += testMultithreadedPost();  
+  errorCount += testExternalPost();
+  if (errorCount != 0)
+    fprintf(stderr, 
+            "Error (code: %u)\n", 
+            errorCount);
+  curl_global_cleanup();
+  return errorCount != 0; /* 0 == pass */
+}
diff --git a/src/daemon/daemontest_put.c b/src/daemon/daemontest_put.c
new file mode 100644
index 00000000..822f44a1
--- /dev/null
+++ b/src/daemon/daemontest_put.c
@@ -0,0 +1,448 @@
+/*
+     This file is part of libmicrohttpd
+     (C) 2007 Christian Grothoff
+
+     libmicrohttpd is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     libmicrohttpd is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with libmicrohttpd; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file daemontest_put.c
+ * @brief  Testcase for libmicrohttpd PUT operations
+ * @author Christian Grothoff
+ */
+
+#include "config.h"
+#include <curl/curl.h>
+#include <microhttpd.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+
+static int apc_all(void * cls,
+                   const struct sockaddr * addr,
+                   socklen_t addrlen) {
+  return MHD_YES;
+}
+
+struct CBC {
+  char * buf;
+  size_t pos;
+  size_t size;
+};
+
+static size_t putBuffer(void * stream,
+                        size_t size,
+                        size_t nmemb,
+                        void * ptr) {
+  unsigned int * pos = ptr;
+  unsigned int wrt;
+
+  wrt = size * nmemb;
+  if (wrt > 8 - (*pos))
+    wrt = 8 - (*pos);
+  memcpy(stream,
+         &("Hello123"[*pos]),
+         wrt);
+  (*pos) += wrt;
+  return wrt;
+}
+
+static size_t copyBuffer(void * ptr,
+                         size_t size,
+                         size_t nmemb,
+                         void * ctx) {
+  struct CBC * cbc = ctx;
+
+  if (cbc->pos + size * nmemb > cbc->size)
+    return 0; /* overflow */
+  memcpy(&cbc->buf[cbc->pos],
+         ptr,
+         size * nmemb);
+  cbc->pos += size * nmemb;
+  return size * nmemb;
+}
+
+static int ahc_echo(void * cls,
+                    struct MHD_Session * session,
+                    const char * url,
+                    const char * method,
+                    const char * upload_data,
+                    unsigned int * upload_data_size) {
+  int * done = cls;
+  struct MHD_Response * response;
+  int ret;
+
+  if (0 != strcmp("PUT", method)) 
+    return MHD_NO; /* unexpected method */  
+  if ((*done) == 0) {
+    if (*upload_data_size != 8) 
+      return MHD_YES; /* not yet ready */    
+    if (0 == memcmp(upload_data,
+                    "Hello123",
+                    8)) {
+      *upload_data_size = 0;
+    } else {    
+      printf("Invalid upload data `%8s'!\n",
+             upload_data);
+      return MHD_NO;
+    }
+    *done = 1;
+    return MHD_YES;
+  }
+  response = MHD_create_response_from_data(strlen(url),
+                                           (void*) url,
+                                           MHD_NO,
+                                           MHD_YES);
+  ret = MHD_queue_response(session,
+                           MHD_HTTP_OK,
+                           response);
+  MHD_destroy_response(response);
+  return ret;
+}
+
+
+static int testInternalPut() {
+  struct MHD_Daemon * d;
+  CURL * c;
+  char buf[2048];
+  struct CBC cbc;
+  unsigned int pos = 0;
+  int done_flag = 0;
+
+  cbc.buf = buf;
+  cbc.size = 2048;
+  cbc.pos = 0;
+  d = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY | MHD_USE_IPv4 | MHD_USE_DEBUG,
+                       1080,
+                       &apc_all,
+                       NULL,
+                       &ahc_echo,
+                       &done_flag);
+  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_WRITEFUNCTION,
+                   &copyBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEDATA,
+                   &cbc);
+  curl_easy_setopt(c,
+                   CURLOPT_READFUNCTION,
+                   &putBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_READDATA,
+                   &pos);
+  curl_easy_setopt(c,
+                   CURLOPT_UPLOAD,
+                   1L);
+  curl_easy_setopt(c,
+                   CURLOPT_INFILESIZE_LARGE,
+                   (curl_off_t) 8L);
+  curl_easy_setopt(c,
+                   CURLOPT_FAILONERROR,
+                   1);
+  curl_easy_setopt(c,
+                   CURLOPT_TIMEOUT,
+                   15L);
+  curl_easy_setopt(c,
+                   CURLOPT_CONNECTTIMEOUT,
+                   15L);
+  // NOTE: use of CONNECTTIMEOUT without also
+  //   setting NOSIGNAL results in really weird
+  //   crashes on my system!
+  curl_easy_setopt(c,
+                   CURLOPT_NOSIGNAL,
+                   1);  
+  if (CURLE_OK != curl_easy_perform(c)) {
+    curl_easy_cleanup(c);  
+    MHD_stop_daemon(d);  
+    return 2;
+  }    
+  curl_easy_cleanup(c);  
+  if (cbc.pos != strlen("/hello_world")) {
+    MHD_stop_daemon(d);
+    return 4;
+  }
+  
+  if (0 != strncmp("/hello_world",
+                   cbc.buf,
+                   strlen("/hello_world"))) {
+    MHD_stop_daemon(d);
+    return 8;
+  }
+  MHD_stop_daemon(d);
+  
+  return 0;
+}
+
+static int testMultithreadedPut() {
+  struct MHD_Daemon * d;
+  CURL * c;
+  char buf[2048];
+  struct CBC cbc;
+  unsigned int pos = 0;
+  int done_flag = 0;
+
+  cbc.buf = buf;
+  cbc.size = 2048;
+  cbc.pos = 0;
+  d = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_IPv4 | MHD_USE_DEBUG,
+                       1081,
+                       &apc_all,
+                       NULL,
+                       &ahc_echo,
+                       &done_flag);
+  if (d == NULL)
+    return 16;
+  c = curl_easy_init();
+  curl_easy_setopt(c,
+                   CURLOPT_URL,
+                   "http://localhost:1081/hello_world");
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEFUNCTION,
+                   &copyBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEDATA,
+                   &cbc);
+  curl_easy_setopt(c,
+                   CURLOPT_READFUNCTION,
+                   &putBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_READDATA,
+                   &pos);
+  curl_easy_setopt(c,
+                   CURLOPT_UPLOAD,
+                   1L);
+  curl_easy_setopt(c,
+                   CURLOPT_INFILESIZE_LARGE,
+                   (curl_off_t) 8L);
+  curl_easy_setopt(c,
+                   CURLOPT_FAILONERROR,
+                   1);
+  curl_easy_setopt(c,
+                   CURLOPT_TIMEOUT,
+                   15L);
+  curl_easy_setopt(c,
+                   CURLOPT_CONNECTTIMEOUT,
+                   15L);
+  // NOTE: use of CONNECTTIMEOUT without also
+  //   setting NOSIGNAL results in really weird
+  //   crashes on my system!
+  curl_easy_setopt(c,
+                   CURLOPT_NOSIGNAL,
+                   1);  
+  if (CURLE_OK != curl_easy_perform(c)) {
+    curl_easy_cleanup(c);
+    MHD_stop_daemon(d);  
+    return 32;
+  }
+  curl_easy_cleanup(c);
+  if (cbc.pos != strlen("/hello_world")) {
+    MHD_stop_daemon(d);  
+    return 64;
+  }  
+  if (0 != strncmp("/hello_world",
+                   cbc.buf,
+                   strlen("/hello_world"))) {
+    MHD_stop_daemon(d);
+    return 128;
+  }
+  MHD_stop_daemon(d);
+  
+  return 0;
+}
+
+
+static int testExternalPut() {
+  struct MHD_Daemon * d;
+  CURL * c;
+  char buf[2048];
+  struct CBC cbc;
+  CURLM * multi;
+  CURLMcode mret;
+  fd_set rs;
+  fd_set ws;
+  fd_set es;
+  int max;
+  int running;
+  struct CURLMsg * msg;
+  time_t start;
+  struct timeval tv;
+  unsigned int pos = 0;
+  int done_flag = 0;
+
+  multi = NULL;
+  cbc.buf = buf;
+  cbc.size = 2048;
+  cbc.pos = 0;
+  d = MHD_start_daemon(MHD_USE_IPv4 | MHD_USE_DEBUG,
+                       1082,
+                       &apc_all,
+                       NULL,
+                       &ahc_echo,
+                       &done_flag);
+  if (d == NULL)
+    return 256;
+  c = curl_easy_init();
+  curl_easy_setopt(c,
+                   CURLOPT_URL,
+                   "http://localhost:1082/hello_world");
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEFUNCTION,
+                   &copyBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_WRITEDATA,
+                   &cbc);
+  curl_easy_setopt(c,
+                   CURLOPT_READFUNCTION,
+                   &putBuffer);
+  curl_easy_setopt(c,
+                   CURLOPT_READDATA,
+                   &pos);
+  curl_easy_setopt(c,
+                   CURLOPT_UPLOAD,
+                   1L);
+  curl_easy_setopt(c,
+                   CURLOPT_INFILESIZE_LARGE,
+                   (curl_off_t) 8L);
+  curl_easy_setopt(c,
+                   CURLOPT_FAILONERROR,
+                   1);
+  curl_easy_setopt(c,
+                   CURLOPT_TIMEOUT,
+                   15L);
+  curl_easy_setopt(c,
+                   CURLOPT_CONNECTTIMEOUT,
+                   15L);
+  // NOTE: use of CONNECTTIMEOUT without also
+  //   setting NOSIGNAL results in really weird
+  //   crashes on my system!
+  curl_easy_setopt(c,
+                   CURLOPT_NOSIGNAL,
+                   1);  
+
+
+  multi = curl_multi_init();
+  if (multi == NULL) {
+    curl_easy_cleanup(c);  
+    MHD_stop_daemon(d);  
+    return 512;
+  }
+  mret = curl_multi_add_handle(multi, c);
+  if (mret != CURLM_OK) {
+    curl_multi_cleanup(multi);
+    curl_easy_cleanup(c);  
+    MHD_stop_daemon(d);  
+    return 1024;
+  }
+  start = time(NULL);
+  while ( (time(NULL) - start < 5) &&
+          (multi != NULL) ) {
+    max = 0;
+    FD_ZERO(&rs);
+    FD_ZERO(&ws);
+    FD_ZERO(&es);
+    curl_multi_perform(multi, &running);
+    mret = curl_multi_fdset(multi,
+                            &rs,
+                            &ws,
+                            &es,
+                            &max);
+    if (mret != CURLM_OK) {
+      curl_multi_remove_handle(multi, c);
+      curl_multi_cleanup(multi);
+      curl_easy_cleanup(c);  
+      MHD_stop_daemon(d);  
+      return 2048;    
+    }
+    if (MHD_YES != MHD_get_fdset(d,
+                                 &rs,
+                                 &ws,
+                                 &es,
+                                 &max)) {
+      curl_multi_remove_handle(multi, c);
+      curl_multi_cleanup(multi);
+      curl_easy_cleanup(c);        
+      MHD_stop_daemon(d);  
+      return 4096;
+    }
+    tv.tv_sec = 0;
+    tv.tv_usec = 1000;
+    select(max + 1,
+           &rs,
+           &ws,
+           &es,
+           &tv);  
+    curl_multi_perform(multi, &running);
+    if (running == 0) {
+      msg = curl_multi_info_read(multi,
+                                 &running);
+      if (msg == NULL)
+        break;
+      if (msg->msg == CURLMSG_DONE) {
+        if (msg->data.result != CURLE_OK)
+          printf("%s failed at %s:%d: `%s'\n",
+                 "curl_multi_perform",
+                 __FILE__,
+                 __LINE__,
+                 curl_easy_strerror(msg->data.result));
+        curl_multi_remove_handle(multi, c);
+        curl_multi_cleanup(multi);
+        curl_easy_cleanup(c);
+        c = NULL;
+        multi = NULL;
+      }
+    }   
+    MHD_run(d);
+  }
+  if (multi != NULL) {
+    curl_multi_remove_handle(multi, c);
+    curl_easy_cleanup(c);  
+    curl_multi_cleanup(multi);
+  }
+  MHD_stop_daemon(d);
+  if (cbc.pos != strlen("/hello_world")) 
+    return 8192;
+  if (0 != strncmp("/hello_world",
+                   cbc.buf,
+                   strlen("/hello_world"))) 
+    return 16384;
+  return 0;
+}
+
+
+
+int main(int argc,
+         char * const * argv) {
+  unsigned int errorCount = 0;
+
+  if (0 != curl_global_init(CURL_GLOBAL_WIN32)) 
+    return 2;  
+  errorCount += testInternalPut();
+  errorCount += testMultithreadedPut();  
+  errorCount += testExternalPut();
+  if (errorCount != 0)
+    fprintf(stderr, 
+            "Error (code: %u)\n", 
+            errorCount);
+  curl_global_cleanup();
+  return errorCount != 0; /* 0 == pass */
+}
diff --git a/src/daemon/session.c b/src/daemon/session.c
index 1af59e84..84ed6bc2 100644
--- a/src/daemon/session.c
+++ b/src/daemon/session.c
@@ -131,17 +131,22 @@ MHD_session_get_fdset(struct MHD_Session * session,
                       fd_set * write_fd_set,
                       fd_set * except_fd_set,
                       int * max_fd) {
+  int fd;
+
+  fd = session->socket_fd;
+  if (fd == -1)
+    return MHD_YES;
   if ( (session->read_close == 0) && 
        ( (session->headersReceived == 0) ||
          (session->readLoc < session->read_buffer_size) ) )
-    FD_SET(session->socket_fd, read_fd_set);
+    FD_SET(fd, read_fd_set);
   if (session->response != NULL) 
-    FD_SET(session->socket_fd, write_fd_set);
-  if ( (session->socket_fd > *max_fd) &&
+    FD_SET(fd, write_fd_set);
+  if ( (fd > *max_fd) &&
        ( (session->headersReceived == 0) ||
          (session->readLoc < session->read_buffer_size) ||
          (session->response != NULL) ) )
-    *max_fd = session->socket_fd;
+    *max_fd = fd;
   return MHD_YES;
 }
 
@@ -479,9 +484,9 @@ MHD_call_session_handler(struct MHD_Session * session) {
   memmove(session->read_buffer,
           &session->read_buffer[session->readLoc - processed],
           processed);
-  session->readLoc = processed;
   if (session->uploadSize != -1)
-    session->uploadSize -= processed;
+    session->uploadSize -= (session->readLoc - processed); 
+  session->readLoc = processed;
   if ( (session->uploadSize == 0) ||
        ( (session->readLoc == 0) &&
          (session->uploadSize == -1) &&