libmicrohttpd

test_large_put.c (28069B)

---

 /*
      This file is part of libmicrohttpd
      Copyright (C) 2007, 2008 Christian Grothoff
      Copyright (C) 2014-2022 Evgeny Grin (Karlson2k)
 
      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., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
 */
 
 /**
  * @file test_large_put.c
  * @brief  Testcase for libmicrohttpd PUT operations
  * @author Christian Grothoff
  * @author Karlson2k (Evgeny Grin)
  */
 
 #include "MHD_config.h"
 #include "platform.h"
 #include <curl/curl.h>
 #include <microhttpd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <errno.h>
 
 #ifndef WINDOWS
 #include <unistd.h>
 #endif
 
 #include "mhd_has_in_name.h"
 #include "mhd_has_param.h"
 
 #if defined(MHD_CPU_COUNT) && (MHD_CPU_COUNT + 0) < 2
 #undef MHD_CPU_COUNT
 #endif
 #if ! defined(MHD_CPU_COUNT)
 #define MHD_CPU_COUNT 2
 #endif
 
 
 #if defined(HAVE___FUNC__)
 #define externalErrorExit(ignore) \
     _externalErrorExit_func(NULL, __func__, __LINE__)
 #define externalErrorExitDesc(errDesc) \
     _externalErrorExit_func(errDesc, __func__, __LINE__)
 #define libcurlErrorExit(ignore) \
     _libcurlErrorExit_func(NULL, __func__, __LINE__)
 #define libcurlErrorExitDesc(errDesc) \
     _libcurlErrorExit_func(errDesc, __func__, __LINE__)
 #define mhdErrorExit(ignore) \
     _mhdErrorExit_func(NULL, __func__, __LINE__)
 #define mhdErrorExitDesc(errDesc) \
     _mhdErrorExit_func(errDesc, __func__, __LINE__)
 #elif defined(HAVE___FUNCTION__)
 #define externalErrorExit(ignore) \
     _externalErrorExit_func(NULL, __FUNCTION__, __LINE__)
 #define externalErrorExitDesc(errDesc) \
     _externalErrorExit_func(errDesc, __FUNCTION__, __LINE__)
 #define libcurlErrorExit(ignore) \
     _libcurlErrorExit_func(NULL, __FUNCTION__, __LINE__)
 #define libcurlErrorExitDesc(errDesc) \
     _libcurlErrorExit_func(errDesc, __FUNCTION__, __LINE__)
 #define mhdErrorExit(ignore) \
     _mhdErrorExit_func(NULL, __FUNCTION__, __LINE__)
 #define mhdErrorExitDesc(errDesc) \
     _mhdErrorExit_func(errDesc, __FUNCTION__, __LINE__)
 #else
 #define externalErrorExit(ignore) _externalErrorExit_func(NULL, NULL, __LINE__)
 #define externalErrorExitDesc(errDesc) \
   _externalErrorExit_func(errDesc, NULL, __LINE__)
 #define libcurlErrorExit(ignore) _libcurlErrorExit_func(NULL, NULL, __LINE__)
 #define libcurlErrorExitDesc(errDesc) \
   _libcurlErrorExit_func(errDesc, NULL, __LINE__)
 #define mhdErrorExit(ignore) _mhdErrorExit_func(NULL, NULL, __LINE__)
 #define mhdErrorExitDesc(errDesc) _mhdErrorExit_func(errDesc, NULL, __LINE__)
 #endif
 
 
 _MHD_NORETURN static void
 _externalErrorExit_func (const char *errDesc, const char *funcName, int lineNum)
 {
   if ((NULL != errDesc) && (0 != errDesc[0]))
     fprintf (stderr, "%s", errDesc);
   else
     fprintf (stderr, "System or external library call failed");
   if ((NULL != funcName) && (0 != funcName[0]))
     fprintf (stderr, " in %s", funcName);
   if (0 < lineNum)
     fprintf (stderr, " at line %d", lineNum);
 
   fprintf (stderr, ".\nLast errno value: %d (%s)\n", (int) errno,
            strerror (errno));
 #ifdef MHD_WINSOCK_SOCKETS
   fprintf (stderr, "WSAGetLastError() value: %d\n", (int) WSAGetLastError ());
 #endif /* MHD_WINSOCK_SOCKETS */
   fflush (stderr);
   exit (99);
 }
 
 
 static char libcurl_errbuf[CURL_ERROR_SIZE] = "";
 
 _MHD_NORETURN static void
 _libcurlErrorExit_func (const char *errDesc, const char *funcName, int lineNum)
 {
   if ((NULL != errDesc) && (0 != errDesc[0]))
     fprintf (stderr, "%s", errDesc);
   else
     fprintf (stderr, "CURL library call failed");
   if ((NULL != funcName) && (0 != funcName[0]))
     fprintf (stderr, " in %s", funcName);
   if (0 < lineNum)
     fprintf (stderr, " at line %d", lineNum);
 
   fprintf (stderr, ".\nLast errno value: %d (%s)\n", (int) errno,
            strerror (errno));
   if (0 != libcurl_errbuf[0])
     fprintf (stderr, "Last libcurl error details: %s\n", libcurl_errbuf);
 
   fflush (stderr);
   exit (99);
 }
 
 
 _MHD_NORETURN static void
 _mhdErrorExit_func (const char *errDesc, const char *funcName, int lineNum)
 {
   if ((NULL != errDesc) && (0 != errDesc[0]))
     fprintf (stderr, "%s", errDesc);
   else
     fprintf (stderr, "MHD unexpected error");
   if ((NULL != funcName) && (0 != funcName[0]))
     fprintf (stderr, " in %s", funcName);
   if (0 < lineNum)
     fprintf (stderr, " at line %d", lineNum);
 
   fprintf (stderr, ".\nLast errno value: %d (%s)\n", (int) errno,
            strerror (errno));
 
   fflush (stderr);
   exit (8);
 }
 
 
 static int oneone;
 static int incr_read; /* Use incremental read */
 static int verbose; /* Be verbose */
 
 #define PUT_SIZE (256 * 1024)
 
 static char *put_buffer;
 
 struct CBC
 {
   char *buf;
   size_t pos;
   size_t size;
 };
 
 static char *
 alloc_init (size_t buf_size)
 {
   static const char template[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz";
   static const size_t templ_size = sizeof(template) / sizeof(char) - 1;
   char *buf;
   char *fill_ptr;
   size_t to_fill;
 
   buf = malloc (buf_size);
   if (NULL == buf)
     externalErrorExit ();
 
   fill_ptr = buf;
   to_fill = buf_size;
   while (to_fill > 0)
   {
     const size_t to_copy = to_fill > templ_size ? templ_size : to_fill;
     memcpy (fill_ptr, template, to_copy);
     fill_ptr += to_copy;
     to_fill -= to_copy;
   }
   return buf;
 }
 
 
 static size_t
 putBuffer (void *stream, size_t size, size_t nmemb, void *ptr)
 {
   size_t *pos = (size_t *) ptr;
   size_t wrt;
 
   wrt = size * nmemb;
   /* Check for overflow. */
   if (wrt / size != nmemb)
     libcurlErrorExitDesc ("Too large buffer size");
   if (wrt > PUT_SIZE - (*pos))
     wrt = PUT_SIZE - (*pos);
   memcpy (stream, &put_buffer[*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)
     libcurlErrorExitDesc ("Too large buffer size");
   memcpy (&cbc->buf[cbc->pos], ptr, size * nmemb);
   cbc->pos += size * nmemb;
   return size * nmemb;
 }
 
 
 static enum MHD_Result
 ahc_echo (void *cls,
           struct MHD_Connection *connection,
           const char *url,
           const char *method,
           const char *version,
           const char *upload_data, size_t *upload_data_size,
           void **req_cls)
 {
   int *done = cls;
   struct MHD_Response *response;
   enum MHD_Result ret;
   static size_t processed;
 
   if (NULL == cls)
     mhdErrorExitDesc ("cls parameter is NULL");
 
   if (0 != strcmp (version, oneone ?
                    MHD_HTTP_VERSION_1_1 : MHD_HTTP_VERSION_1_0))
     mhdErrorExitDesc ("Unexpected HTTP version");
 
   if (NULL == url)
     mhdErrorExitDesc ("url parameter is NULL");
 
   if (NULL == upload_data_size)
     mhdErrorExitDesc ("'upload_data_size' pointer is NULL");
 
   if (0 != strcmp ("PUT", method))
     mhdErrorExitDesc ("Unexpected request method");   /* unexpected method */
 
   if ((*done) == 0)
   {
     size_t *pproc;
     if (NULL == *req_cls)
     {
       processed = 0;
       /* Safe as long as only one parallel request served. */
       *req_cls = &processed;
     }
     pproc = (size_t *) *req_cls;
 
     if (0 == *upload_data_size)
       return MHD_YES;   /* No data to process. */
 
     if (*pproc + *upload_data_size > PUT_SIZE)
       mhdErrorExitDesc ("Incoming data larger than expected");
 
     if ( (! incr_read) && (*upload_data_size != PUT_SIZE) )
       return MHD_YES;   /* Wait until whole request is received. */
 
     if (0 != memcmp (upload_data, put_buffer + (*pproc), *upload_data_size))
       mhdErrorExitDesc ("Incoming data does not match sent data");
 
     *pproc += *upload_data_size;
     *upload_data_size = 0;   /* Current block of data is fully processed. */
 
     if (PUT_SIZE == *pproc)
       *done = 1;   /* Whole request is processed. */
     return MHD_YES;
   }
   response =
     MHD_create_response_from_buffer_copy (strlen (url),
                                           (const void *) url);
   if (NULL == response)
     mhdErrorExitDesc ("Failed to create response");
   ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
   MHD_destroy_response (response);
   return ret;
 }
 
 
 static unsigned int
 testPutInternalThread (unsigned int add_flag)
 {
   struct MHD_Daemon *d;
   CURL *c;
   struct CBC cbc;
   size_t pos = 0;
   int done_flag = 0;
   CURLcode errornum;
   char buf[2048];
   uint16_t port;
 
   if (MHD_NO != MHD_is_feature_supported (MHD_FEATURE_AUTODETECT_BIND_PORT))
     port = 0;
   else
   {
     port = 1270;
     if (oneone)
       port += 10;
     if (incr_read)
       port += 20;
   }
 
   cbc.buf = buf;
   cbc.size = 2048;
   cbc.pos = 0;
   d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG
                         | add_flag,
                         port,
                         NULL, NULL, &ahc_echo, &done_flag,
                         MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                         (size_t) (incr_read ? 1024 : (PUT_SIZE * 4 / 3)),
                         MHD_OPTION_END);
   if (d == NULL)
     mhdErrorExit ();
   if (0 == port)
   {
     const union MHD_DaemonInfo *dinfo;
     dinfo = MHD_get_daemon_info (d, MHD_DAEMON_INFO_BIND_PORT);
     if ((NULL == dinfo) || (0 == dinfo->port) )
       mhdErrorExit ();
     port = dinfo->port;
   }
 
   c = curl_easy_init ();
   if (NULL == c)
   {
     fprintf (stderr, "curl_easy_init() failed.\n");
     externalErrorExit ();
   }
   if ((CURLE_OK != curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_URL,
                                      "http://127.0.0.1/hello_world")) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_PORT, (long) port)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEFUNCTION,
                                      &copyBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READFUNCTION,
                                      &putBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READDATA, &pos)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_UPLOAD, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_INFILESIZE, (long) PUT_SIZE)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_FAILONERROR, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_ERRORBUFFER, libcurl_errbuf)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_TIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_HTTP_VERSION,
                                      (oneone) ?
                                      CURL_HTTP_VERSION_1_1 :
                                      CURL_HTTP_VERSION_1_0)))
 
   {
     fprintf (stderr, "curl_easy_setopt() failed.\n");
     externalErrorExit ();
   }
 
   if (CURLE_OK != (errornum = curl_easy_perform (c)))
   {
     fprintf (stderr,
              "curl_easy_perform failed: `%s'\n",
              curl_easy_strerror (errornum));
     curl_easy_cleanup (c);
     MHD_stop_daemon (d);
     return 2;
   }
   curl_easy_cleanup (c);
   MHD_stop_daemon (d);
   if (cbc.pos != strlen ("/hello_world"))
   {
     fprintf (stderr, "Got %u bytes ('%.*s'), expected %u bytes. ",
              (unsigned) cbc.pos, (int) cbc.pos, cbc.buf,
              (unsigned) strlen ("/hello_world"));
     mhdErrorExitDesc ("Wrong returned data length");
   }
   if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
   {
     fprintf (stderr, "Got invalid response '%.*s'. ", (int) cbc.pos, cbc.buf);
     mhdErrorExitDesc ("Wrong returned data length");
   }
   return 0;
 }
 
 
 static unsigned int
 testPutThreadPerConn (unsigned int add_flag)
 {
   struct MHD_Daemon *d;
   CURL *c;
   struct CBC cbc;
   size_t pos = 0;
   int done_flag = 0;
   CURLcode errornum;
   char buf[2048];
   uint16_t port;
 
   if (MHD_NO != MHD_is_feature_supported (MHD_FEATURE_AUTODETECT_BIND_PORT))
     port = 0;
   else
   {
     port = 1271;
     if (oneone)
       port += 10;
     if (incr_read)
       port += 20;
   }
 
   cbc.buf = buf;
   cbc.size = 2048;
   cbc.pos = 0;
   d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION
                         | MHD_USE_INTERNAL_POLLING_THREAD
                         | MHD_USE_ERROR_LOG | add_flag,
                         port,
                         NULL, NULL, &ahc_echo, &done_flag,
                         MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                         (size_t) (incr_read ? 1024 : (PUT_SIZE * 4)),
                         MHD_OPTION_END);
   if (d == NULL)
     mhdErrorExit ();
   if (0 == port)
   {
     const union MHD_DaemonInfo *dinfo;
     dinfo = MHD_get_daemon_info (d, MHD_DAEMON_INFO_BIND_PORT);
     if ((NULL == dinfo) || (0 == dinfo->port) )
       mhdErrorExit ();
     port = dinfo->port;
   }
 
   c = curl_easy_init ();
   if (NULL == c)
   {
     fprintf (stderr, "curl_easy_init() failed.\n");
     externalErrorExit ();
   }
   if ((CURLE_OK != curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_URL,
                                      "http://127.0.0.1/hello_world")) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_PORT, (long) port)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEFUNCTION,
                                      &copyBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READFUNCTION,
                                      &putBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READDATA, &pos)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_UPLOAD, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_INFILESIZE, (long) PUT_SIZE)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_FAILONERROR, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_ERRORBUFFER, libcurl_errbuf)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_TIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_HTTP_VERSION,
                                      (oneone) ?
                                      CURL_HTTP_VERSION_1_1 :
                                      CURL_HTTP_VERSION_1_0)))
   {
     fprintf (stderr, "curl_easy_setopt() failed.\n");
     externalErrorExit ();
   }
 
   if (CURLE_OK != (errornum = curl_easy_perform (c)))
   {
     fprintf (stderr,
              "curl_easy_perform failed: `%s'\n",
              curl_easy_strerror (errornum));
     curl_easy_cleanup (c);
     MHD_stop_daemon (d);
     return 32;
   }
   curl_easy_cleanup (c);
   MHD_stop_daemon (d);
   if (cbc.pos != strlen ("/hello_world"))
   {
     fprintf (stderr, "Got %u bytes ('%.*s'), expected %u bytes. ",
              (unsigned) cbc.pos, (int) cbc.pos, cbc.buf,
              (unsigned) strlen ("/hello_world"));
     mhdErrorExitDesc ("Wrong returned data length");
   }
   if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
   {
     fprintf (stderr, "Got invalid response '%.*s'. ", (int) cbc.pos, cbc.buf);
     mhdErrorExitDesc ("Wrong returned data length");
   }
   return 0;
 }
 
 
 static unsigned int
 testPutThreadPool (unsigned int add_flag)
 {
   struct MHD_Daemon *d;
   CURL *c;
   struct CBC cbc;
   size_t pos = 0;
   int done_flag = 0;
   CURLcode errornum;
   char buf[2048];
   uint16_t port;
 
   if (MHD_NO != MHD_is_feature_supported (MHD_FEATURE_AUTODETECT_BIND_PORT))
     port = 0;
   else
   {
     port = 1272;
     if (oneone)
       port += 10;
     if (incr_read)
       port += 20;
   }
 
   cbc.buf = buf;
   cbc.size = 2048;
   cbc.pos = 0;
   d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG
                         | add_flag,
                         port,
                         NULL, NULL, &ahc_echo, &done_flag,
                         MHD_OPTION_THREAD_POOL_SIZE, MHD_CPU_COUNT,
                         MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                         (size_t) (incr_read ? 1024 : (PUT_SIZE * 4)),
                         MHD_OPTION_END);
   if (d == NULL)
     mhdErrorExit ();
   if (0 == port)
   {
     const union MHD_DaemonInfo *dinfo;
     dinfo = MHD_get_daemon_info (d, MHD_DAEMON_INFO_BIND_PORT);
     if ((NULL == dinfo) || (0 == dinfo->port) )
       mhdErrorExit ();
     port = dinfo->port;
   }
 
   c = curl_easy_init ();
   if (NULL == c)
   {
     fprintf (stderr, "curl_easy_init() failed.\n");
     externalErrorExit ();
   }
   if ((CURLE_OK != curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_URL,
                                      "http://127.0.0.1/hello_world")) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_PORT, (long) port)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEFUNCTION,
                                      &copyBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READFUNCTION,
                                      &putBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READDATA, &pos)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_UPLOAD, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_INFILESIZE, (long) PUT_SIZE)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_FAILONERROR, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_ERRORBUFFER, libcurl_errbuf)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_TIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_HTTP_VERSION,
                                      (oneone) ?
                                      CURL_HTTP_VERSION_1_1 :
                                      CURL_HTTP_VERSION_1_0)))
   {
     fprintf (stderr, "curl_easy_setopt() failed.\n");
     externalErrorExit ();
   }
   if (CURLE_OK != (errornum = curl_easy_perform (c)))
   {
     fprintf (stderr,
              "curl_easy_perform failed: `%s'\n",
              curl_easy_strerror (errornum));
     curl_easy_cleanup (c);
     MHD_stop_daemon (d);
     return 32;
   }
   curl_easy_cleanup (c);
   MHD_stop_daemon (d);
   if (cbc.pos != strlen ("/hello_world"))
   {
     fprintf (stderr, "Got %u bytes ('%.*s'), expected %u bytes. ",
              (unsigned) cbc.pos, (int) cbc.pos, cbc.buf,
              (unsigned) strlen ("/hello_world"));
     mhdErrorExitDesc ("Wrong returned data length");
   }
   if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
   {
     fprintf (stderr, "Got invalid response '%.*s'. ", (int) cbc.pos, cbc.buf);
     mhdErrorExitDesc ("Wrong returned data length");
   }
   return 0;
 }
 
 
 static unsigned int
 testPutExternal (void)
 {
   struct MHD_Daemon *d;
   CURL *c;
   struct CBC cbc;
   CURLM *multi;
   CURLMcode mret;
   fd_set rs;
   fd_set ws;
   fd_set es;
   int running;
   struct CURLMsg *msg;
   time_t start;
   struct timeval tv;
   size_t pos = 0;
   int done_flag = 0;
   char buf[2048];
   uint16_t port;
 
   if (MHD_NO != MHD_is_feature_supported (MHD_FEATURE_AUTODETECT_BIND_PORT))
     port = 0;
   else
   {
     port = 1273;
     if (oneone)
       port += 10;
     if (incr_read)
       port += 20;
   }
 
   cbc.buf = buf;
   cbc.size = 2048;
   cbc.pos = 0;
   multi = NULL;
   d = MHD_start_daemon (MHD_USE_ERROR_LOG | MHD_USE_NO_THREAD_SAFETY,
                         port,
                         NULL, NULL, &ahc_echo, &done_flag,
                         MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                         (size_t) (incr_read ? 1024 : (PUT_SIZE * 4)),
                         MHD_OPTION_APP_FD_SETSIZE, (int) FD_SETSIZE,
                         MHD_OPTION_END);
   if (d == NULL)
     mhdErrorExit ();
   if (0 == port)
   {
     const union MHD_DaemonInfo *dinfo;
     dinfo = MHD_get_daemon_info (d, MHD_DAEMON_INFO_BIND_PORT);
     if ((NULL == dinfo) || (0 == dinfo->port) )
       mhdErrorExit ();
     port = dinfo->port;
   }
 
   c = curl_easy_init ();
   if (NULL == c)
   {
     fprintf (stderr, "curl_easy_init() failed.\n");
     externalErrorExit ();
   }
   if ((CURLE_OK != curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_URL,
                                      "http://127.0.0.1/hello_world")) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_PORT, (long) port)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEFUNCTION,
                                      &copyBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READFUNCTION,
                                      &putBuffer)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_READDATA, &pos)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_UPLOAD, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_INFILESIZE, (long) PUT_SIZE)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_FAILONERROR, 1L)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_ERRORBUFFER, libcurl_errbuf)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_TIMEOUT,
                                      (long) 150)) ||
       (CURLE_OK != curl_easy_setopt (c, CURLOPT_HTTP_VERSION,
                                      (oneone) ?
                                      CURL_HTTP_VERSION_1_1 :
                                      CURL_HTTP_VERSION_1_0)))
   {
     fprintf (stderr, "curl_easy_setopt() failed.\n");
     externalErrorExit ();
   }
 
   multi = curl_multi_init ();
   if (multi == NULL)
     libcurlErrorExit ();
   mret = curl_multi_add_handle (multi, c);
   if (mret != CURLM_OK)
     libcurlErrorExit ();
 
   start = time (NULL);
   while ((time (NULL) - start < 45) && (multi != NULL))
   {
     MHD_socket maxMHDsock;
     int maxcurlsock;
     maxMHDsock = MHD_INVALID_SOCKET;
     maxcurlsock = -1;
     FD_ZERO (&rs);
     FD_ZERO (&ws);
     FD_ZERO (&es);
     mret = curl_multi_perform (multi, &running);
     if ((CURLM_OK != mret) && (CURLM_CALL_MULTI_PERFORM != mret))
     {
       fprintf (stderr, "curl_multi_perform() failed. Error: '%s'. ",
                curl_multi_strerror (mret));
       libcurlErrorExit ();
     }
     if (CURLM_OK != curl_multi_fdset (multi, &rs, &ws, &es, &maxcurlsock))
       libcurlErrorExitDesc ("curl_multi_fdset() failed");
     if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &maxMHDsock))
       mhdErrorExit ();
 
     tv.tv_sec = 0;
     tv.tv_usec = 1000;
 #ifndef MHD_WINSOCK_SOCKETS
     if (maxMHDsock > maxcurlsock)
       maxcurlsock = maxMHDsock;
 #endif /* MHD_WINSOCK_SOCKETS */
     if (-1 == select (maxcurlsock + 1, &rs, &ws, &es, &tv))
     {
 #ifdef MHD_POSIX_SOCKETS
       if (EINTR != errno)
         externalErrorExitDesc ("Unexpected select() error");
 #else
       if ((WSAEINVAL != WSAGetLastError ()) ||
           (0 != rs.fd_count) || (0 != ws.fd_count) || (0 != es.fd_count) )
         externalErrorExitDesc ("Unexpected select() error");
       Sleep ((DWORD) (tv.tv_sec * 1000 + tv.tv_usec / 1000));
 #endif
     }
 
     mret = curl_multi_perform (multi, &running);
     if ((CURLM_OK != mret) && (CURLM_CALL_MULTI_PERFORM != mret))
     {
       fprintf (stderr, "curl_multi_perform() failed. Error: '%s'. ",
                curl_multi_strerror (mret));
       libcurlErrorExit ();
     }
     if (0 == running)
     {
       int pending;
       int curl_fine = 0;
       while (NULL != (msg = curl_multi_info_read (multi, &pending)))
       {
         if (msg->msg == CURLMSG_DONE)
         {
           if (msg->data.result == CURLE_OK)
             curl_fine = 1;
           else
           {
             fprintf (stderr,
                      "curl_multi_perform() failed: '%s' ",
                      curl_easy_strerror (msg->data.result));
             libcurlErrorExit ();
           }
         }
       }
       if (! curl_fine)
       {
         fprintf (stderr, "libcurl haven't returned OK code ");
         mhdErrorExit ();
       }
       curl_multi_remove_handle (multi, c);
       curl_multi_cleanup (multi);
       curl_easy_cleanup (c);
       c = NULL;
       multi = NULL;
     }
     MHD_run (d);
   }
   if (multi != NULL)
     mhdErrorExitDesc ("Request has been aborted by timeout");
 
   MHD_stop_daemon (d);
   if (cbc.pos != strlen ("/hello_world"))
   {
     fprintf (stderr, "Got %u bytes ('%.*s'), expected %u bytes. ",
              (unsigned) cbc.pos, (int) cbc.pos, cbc.buf,
              (unsigned) strlen ("/hello_world"));
     mhdErrorExitDesc ("Wrong returned data length");
   }
   if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
   {
     fprintf (stderr, "Got invalid response '%.*s'. ", (int) cbc.pos, cbc.buf);
     mhdErrorExitDesc ("Wrong returned data length");
   }
   return 0;
 }
 
 
 int
 main (int argc, char *const *argv)
 {
   unsigned int errorCount = 0;
   unsigned int lastErr;
 
   oneone = has_in_name (argv[0], "11");
   incr_read = has_in_name (argv[0], "_inc");
   verbose = has_param (argc, argv, "-v");
   if (0 != curl_global_init (CURL_GLOBAL_WIN32))
     return 99;
   put_buffer = alloc_init (PUT_SIZE);
   if (NULL == put_buffer)
     return 99;
   lastErr = testPutExternal ();
   if (verbose && (0 != lastErr))
     fprintf (stderr, "Error during testing with external select().\n");
   errorCount += lastErr;
   if (MHD_YES == MHD_is_feature_supported (MHD_FEATURE_THREADS))
   {
     lastErr = testPutInternalThread (0);
     if (verbose && (0 != lastErr) )
       fprintf (stderr,
                "Error during testing with internal thread with select().\n");
     errorCount += lastErr;
     lastErr = testPutThreadPerConn (0);
     if (verbose && (0 != lastErr) )
       fprintf (stderr,
                "Error during testing with internal thread per connection with select().\n");
     errorCount += lastErr;
     lastErr = testPutThreadPool (0);
     if (verbose && (0 != lastErr) )
       fprintf (stderr,
                "Error during testing with thread pool per connection with select().\n");
     errorCount += lastErr;
     if (MHD_is_feature_supported (MHD_FEATURE_POLL))
     {
       lastErr = testPutInternalThread (MHD_USE_POLL);
       if (verbose && (0 != lastErr) )
         fprintf (stderr,
                  "Error during testing with internal thread with poll().\n");
       errorCount += lastErr;
       lastErr = testPutThreadPerConn (MHD_USE_POLL);
       if (verbose && (0 != lastErr) )
         fprintf (stderr,
                  "Error during testing with internal thread per connection with poll().\n");
       errorCount += lastErr;
       lastErr = testPutThreadPool (MHD_USE_POLL);
       if (verbose && (0 != lastErr) )
         fprintf (stderr,
                  "Error during testing with thread pool per connection with poll().\n");
       errorCount += lastErr;
     }
     if (MHD_is_feature_supported (MHD_FEATURE_EPOLL))
     {
       lastErr = testPutInternalThread (MHD_USE_EPOLL);
       if (verbose && (0 != lastErr) )
         fprintf (stderr,
                  "Error during testing with internal thread with epoll.\n");
       errorCount += lastErr;
       lastErr = testPutThreadPool (MHD_USE_EPOLL);
       if (verbose && (0 != lastErr) )
         fprintf (stderr,
                  "Error during testing with thread pool per connection with epoll.\n");
       errorCount += lastErr;
     }
   }
   free (put_buffer);
   if (errorCount != 0)
     fprintf (stderr, "Error (code: %u)\n", errorCount);
   else if (verbose)
     printf ("All checks passed successfully.\n");
   curl_global_cleanup ();
   return (errorCount == 0) ? 0 : 1;
 }