experimental code to support flow control for connections via MHD_suspend_connection and MHD_resume_connection

6 files changed, 717 insertions, 479 deletions

diff --git a/ChangeLog b/ChangeLog
index 21259faa..ae249e8f 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+Thu Oct 24 10:40:03 CEST 2013
+        Adding support for connection flow control via
+        MHD_suspend_connection and MHD_resume_connection. -CG
+
 Sat Oct 19 16:40:32 CEST 2013
         Releasing libmicrohttpd 0.9.31. -CG
 
diff --git a/doc/libmicrohttpd.texi b/doc/libmicrohttpd.texi
index 3ff8c2ac..e18c3014 100644
--- a/doc/libmicrohttpd.texi
+++ b/doc/libmicrohttpd.texi
@@ -63,6 +63,7 @@ Free Documentation License".
 * microhttpd-inspect::          Implementing external @code{select}.
 * microhttpd-requests::         Handling requests.
 * microhttpd-responses::        Building responses to requests.
+* microhttpd-flow::             Flow control.
 * microhttpd-dauth::            Utilizing Authentication.
 * microhttpd-post::             Adding a @code{POST} processor.
 * microhttpd-info::             Obtaining and modifying status information.
@@ -132,7 +133,7 @@ used per connection to avoid resource exhaustion.
 
 @section Scope
 
-MHD is currently used in a wide range of implementations. 
+MHD is currently used in a wide range of implementations.
 Examples based on reports we've received from developers include:
 @itemize
 @item Embedded HTTP server on a cortex M3 (128 KB code space)
@@ -148,7 +149,7 @@ Examples based on reports we've received from developers include:
 @cindex select
 
 MHD supports four basic thread modes and up to three event loop
-styes.  
+styes.
 
 The four basic thread modes are external (MHD creates no threads,
 event loop is fully managed by the application), internal (MHD creates
@@ -203,7 +204,7 @@ combinations.
 @item @b{external}              @tab  yes       @tab no       @tab yes
 @item @b{internal}              @tab  yes       @tab yes      @tab yes
 @item @b{thread pool}           @tab  yes       @tab yes      @tab yes
-@item @b{thread-per-connection} @tab  yes       @tab yes      @tab no 
+@item @b{thread-per-connection} @tab  yes       @tab yes      @tab no
 @end multitable
 @caption{Supported combinations of event styles and thread modes.}
 @end float
@@ -239,7 +240,7 @@ full list of options run ``./configure --help''):
 @item ``--disable-curl''
 disable running testcases using libcurl
 
-@item ``--disable-largefile'' 
+@item ``--disable-largefile''
 disable support for 64-bit files
 
 @item ``--disable-messages''
@@ -285,7 +286,7 @@ conditional operations.  For possible suggestions consult
 Once you have ensured that you manually (!) included the right headers
 for your platform before "microhttpd.h", you should also add a line
 with @code{#define MHD_PLATFORM_H} which will prevent the
-"microhttpd.h" header from trying (and, depending on your platform, 
+"microhttpd.h" header from trying (and, depending on your platform,
 failing) to include the right headers.
 
 If you do not define MHD_PLATFORM_H, the "microhttpd.h" header will
@@ -297,12 +298,12 @@ causing problems when porting to other platforms).
 MHD does not install a signal handler for SIGPIPE.  On platforms
 where this is possible (such as GNU/Linux), it disables SIGPIPE for
 its I/O operations (by passing MSG_NOSIGNAL).  On other platforms,
-SIGPIPE signals may be generated from network operations by 
+SIGPIPE signals may be generated from network operations by
 MHD and will cause the process to die unless the developer
 explicitly installs a signal handler for SIGPIPE.
 
 Hence portable code using MHD must install a SIGPIPE handler or
-explicitly block the SIGPIPE signal.  MHD does not do so in order 
+explicitly block the SIGPIPE signal.  MHD does not do so in order
 to avoid messing with other parts of the application that may
 need to handle SIGPIPE in a particular way.  You can make your application handle SIGPIPE by calling the following function in @code{main}:
 
@@ -422,8 +423,8 @@ No options selected.
 Run in debug mode.  If this flag is used, the library should print error
 messages and warnings to stderr.  Note that for this
 run-time option to have any effect, MHD needs to be
-compiled with messages enabled. This is done by default except you ran 
-configure with the @code{--disable-messages} flag set. 
+compiled with messages enabled. This is done by default except you ran
+configure with the @code{--disable-messages} flag set.
 
 @item MHD_USE_SSL
 @cindex TLS
@@ -519,7 +520,7 @@ ability to signal termination via the listen socket).  In these modes,
 @code{MHD_quiesce_daemon} will fail if this option was not set.  Also,
 use of this option is automatic (as in, you do not even have to
 specify it), if @code{MHD_USE_NO_LISTEN_SOCKET} is specified.  In
-"external" select mode, this option is always simply ignored.  
+"external" select mode, this option is always simply ignored.
 
 @end table
 @end deftp
@@ -533,7 +534,7 @@ MHD options.  Passed in the varargs portion of
 @item MHD_OPTION_END
 No more options / last option.  This is used to terminate the VARARGs
 list.
-  
+
 @item MHD_OPTION_CONNECTION_MEMORY_LIMIT
 @cindex memory, limiting memory utilization
 Maximum memory size per connection (followed by a @code{size_t}).  The
@@ -558,19 +559,19 @@ Maximum number of concurrent connections to accept (followed by an
 @code{unsigned int}).  The default is @code{FD_SETSIZE - 4} (the
 maximum number of file descriptors supported by @code{select} minus
 four for @code{stdin}, @code{stdout}, @code{stderr} and the server
-socket).  In other words, the default is as large as possible.  
+socket).  In other words, the default is as large as possible.
 
 Note that if you set a low connection limit, you can easily get into
 trouble with browsers doing request pipelining.  For example, if your
 connection limit is ``1'', a browser may open a first connection to
-access your ``index.html'' file, keep it open but use a second 
+access your ``index.html'' file, keep it open but use a second
 connection to retrieve CSS files, images and the like.  In fact, modern
 browsers are typically by default configured for up to 15 parallel
 connections to a single server.  If this happens, MHD will refuse to
 even accept the second connection until the first connection is
 closed --- which does not happen until timeout.  As a result, the
 browser will fail to render the page and seem to hang.  If you expect
-your server to operate close to the connection limit, you should 
+your server to operate close to the connection limit, you should
 first consider using a lower timeout value and also possibly add
 a ``Connection: close'' header to your response to ensure that
 request pipelining is not used and connections are closed immediately
@@ -613,8 +614,8 @@ from the same IP address.
 @item MHD_OPTION_SOCK_ADDR
 @cindex bind, restricting bind
 Bind daemon to the supplied socket address. This option should be followed by a
-@code{struct sockaddr *}.  If @code{MHD_USE_IPv6} is specified, 
-the @code{struct sockaddr*} should point to a @code{struct sockaddr_in6}, 
+@code{struct sockaddr *}.  If @code{MHD_USE_IPv6} is specified,
+the @code{struct sockaddr*} should point to a @code{struct sockaddr_in6},
 otherwise to a @code{struct sockaddr_in}.  If this option is not specified,
 the daemon will listen to incoming connections from anywhere.  If you use this
 option, the 'port' argument from @code{MHD_start_daemon} is ignored and the port
@@ -655,7 +656,7 @@ Memory pointer to the private key to be used by the
 HTTPS daemon.  This option should be followed by an
 "const char*" argument.
 This should be used in conjunction with 'MHD_OPTION_HTTPS_MEM_CERT'.
-   
+
 @item MHD_OPTION_HTTPS_MEM_CERT
 @cindex SSL
 @cindex TLS
@@ -663,7 +664,7 @@ Memory pointer to the certificate to be used by the
 HTTPS daemon.  This option should be followed by an
 "const char*" argument.
 This should be used in conjunction with 'MHD_OPTION_HTTPS_MEM_KEY'.
-   
+
 @item MHD_OPTION_HTTPS_MEM_TRUST
 @cindex SSL
 @cindex TLS
@@ -677,14 +678,14 @@ of the certificate if needed.
 Note that most browsers will only present a client certificate
 only if they have one matching the specified CA, not sending
 any certificate otherwise.
-   
+
 @item MHD_OPTION_HTTPS_CRED_TYPE
 @cindex SSL
 @cindex TLS
 Daemon credentials type.  Either certificate or anonymous,
 this option should be followed by one of the values listed in
 "enum gnutls_credentials_type_t".
-   
+
 @item MHD_OPTION_HTTPS_PRIORITIES
 @cindex SSL
 @cindex TLS
@@ -706,7 +707,7 @@ type "size_t" which specifies the size of the buffer pointed to by the
 second argument in bytes.  Note that the application must ensure that
 the buffer of the second argument remains allocated and unmodified
 while the daemon is running.  For security, you SHOULD provide a fresh
-random nonce when using MHD with Digest Authentication.  
+random nonce when using MHD with Digest Authentication.
 
 @item MHD_OPTION_NONCE_NC_SIZE
 @cindex digest auth
@@ -737,7 +738,7 @@ Listen socket to use.  Pass a listen socket for MHD to use
 (systemd-style).  If this option is used, MHD will not open its own
 listen socket(s). The argument passed must be of type "int" and refer
 to an existing socket that has been bound to a port and is listening.
-  
+
 @item MHD_OPTION_EXTERNAL_LOGGER
 @cindex logging
 Use the given function for logging error messages.
@@ -746,10 +747,10 @@ first must be a pointer to a function
 of type 'void fun(void * arg, const char * fmt, va_list ap)'
 and the second a pointer of type 'void*' which will
 be passed as the "arg" argument to "fun".
- 
-Note that MHD will not generate any log messages without  
-the MHD_USE_DEBUG flag set and if MHD was compiled 
-with the "--disable-messages" flag. 
+
+Note that MHD will not generate any log messages without
+the MHD_USE_DEBUG flag set and if MHD was compiled
+with the "--disable-messages" flag.
 
 @item MHD_OPTION_THREAD_POOL_SIZE
 @cindex performance
@@ -806,7 +807,7 @@ updated.  Note that the unescape function must not lengthen @code{s}
 @code{cls} will be set to the second argument following
 MHD_OPTION_UNESCAPE_CALLBACK.
 
-  
+
 @item MHD_OPTION_THREAD_STACK_SIZE
 @cindex stack
 @cindex thread
@@ -814,7 +815,7 @@ MHD_OPTION_UNESCAPE_CALLBACK.
 @cindex embedded systems
 Maximum stack size for threads created by MHD.  This option must be
 followed by a @code{size_t}).  Not specifying this option or using
-a value of zero means using the system default (which is likely to 
+a value of zero means using the system default (which is likely to
 differ based on your platform).
 
 @end table
@@ -823,7 +824,7 @@ differ based on your platform).
 
 @deftp {C Struct} MHD_OptionItem
 Entry in an MHD_OPTION_ARRAY.  See the @code{MHD_OPTION_ARRAY} option
-argument for its use. 
+argument for its use.
 
 The @code{option} member is used to specify which option is specified
 in the array.  The other members specify the respective argument.
@@ -895,7 +896,7 @@ We had to close the session since MHD was being shut down.
 
 @deftp {Enumeration} MHD_ResponseMemoryMode
 The @code{MHD_ResponeMemoryMode} specifies how MHD should treat
-the memory buffer given for the response in 
+the memory buffer given for the response in
 @code{MHD_create_response_from_buffer}.
 
 @table @code
@@ -903,12 +904,12 @@ the memory buffer given for the response in
 Buffer is a persistent (static/global) buffer that won't change
 for at least the lifetime of the response, MHD should just use
 it, not free it, not copy it, just keep an alias to it.
- 
+
 @item MHD_RESPMEM_MUST_FREE
 Buffer is heap-allocated with @code{malloc} (or equivalent) and
 should be freed by MHD after processing the response has
 concluded (response reference counter reaches zero).
-  
+
 @item MHD_RESPMEM_MUST_COPY
 Buffer is in transient memory, but not on the heap (for example,
 on the stack or non-malloc allocated) and only valid during the
@@ -1094,13 +1095,9 @@ Callback used by MHD in order to obtain content.  The callback has to
 copy at most @var{max} bytes of content into @var{buf}.  The total
 number of bytes that has been placed into @var{buf} should be returned.
 
-Note that returning zero will cause MHD to try again, either
-``immediately'' if in multi-threaded mode (in which case the callback
-may want to do blocking operations to avoid busy waiting) or in the
-next round if @code{MHD_run} is used.  Returning zero for a daemon
-that runs in internal @code{select}-mode is an error (since it
-would result in busy waiting) and cause the program to be aborted
-(@code{abort()}).
+Note that returning zero will cause MHD to try again.
+Thus, returning zero should only be used in conjunction
+with @code{MHD_suspend_connection()} to avoid busy waiting.
 
 While usually the callback simply returns the number of bytes written
 into @var{buf}, there are two special return value:
@@ -1108,7 +1105,7 @@ into @var{buf}, there are two special return value:
 @code{MHD_CONTENT_READER_END_OF_STREAM} (-1) should be returned
 for the regular end of transmission (with chunked encoding, MHD will then
 terminate the chunk and send any HTTP footers that might be
-present; without chunked encoding and given an unknown 
+present; without chunked encoding and given an unknown
 response size, MHD will simply close the connection; note
 that while returning @code{MHD_CONTENT_READER_END_OF_STREAM} is not technically
 legal if a response size was specified, MHD accepts this
@@ -1121,7 +1118,7 @@ given or if chunked encoding is in use, this will indicate
 an error to the client.  Note, however, that if the client
 does not know a response size and chunked encoding is not in
 use, then clients will not be able to tell the difference between
-@code{MHD_CONTENT_READER_END_WITH_ERROR} and 
+@code{MHD_CONTENT_READER_END_WITH_ERROR} and
 @code{MHD_CONTENT_READER_END_OF_STREAM}.
 This is not a limitation of MHD but rather of the HTTP protocol.
 
@@ -1198,7 +1195,7 @@ iteration.
 Set a handler for fatal errors.
 
 @table @var
-@item cb 
+@item cb
 function to call if MHD encounters a fatal internal error.  If no handler was set explicitly, MHD will call @code{abort}.
 
 @item cls
@@ -1252,7 +1249,7 @@ is still using it).
 
 This function is useful in the special case that a listen socket
 is to be migrated to another process (i.e. a newer version of the
-HTTP server) while existing connections should continue to be 
+HTTP server) while existing connections should continue to be
 processed until they are finished.
 
 Return @code{-1} on error (daemon not listening), the handle to the
@@ -1278,7 +1275,7 @@ However, if using external @code{select} mode, you may want to
 instead use @code{MHD_run_from_select}, as it is more efficient.
 
 @table @var
-@item daemon 
+@item daemon
 daemon to process connections of
 @end table
 
@@ -1291,7 +1288,7 @@ started with the right options for this call.
 Run webserver operations given sets of ready socket handles.
 @cindex select
 
-This method should be called by clients in combination with 
+This method should be called by clients in combination with
 @code{MHD_get_fdset} if the client-controlled (external)
 select method is used.
 
@@ -1303,7 +1300,7 @@ not have to call @code{select} again to determine which operations are
 ready.
 
 @table @var
-@item daemon 
+@item daemon
 daemon to process connections of
 @item read_fd_set
 set of descriptors that must be ready for reading without blocking
@@ -1321,11 +1318,11 @@ errors.
 
 
 @deftypefun void MHD_add_connection (struct MHD_Daemon *daemon, int client_socket, const struct sockaddr *addr, socklen_t addrlen)
-Add another client connection to the set of connections 
+Add another client connection to the set of connections
 managed by MHD.  This API is usually not needed (since
 MHD will accept inbound connections on the server socket).
 Use this API in special cases, for example if your HTTP
-server is behind NAT and needs to connect out to the 
+server is behind NAT and needs to connect out to the
 HTTP client, or if you are building a proxy.
 
 If you use this API in conjunction with a internal select or a thread
@@ -1338,17 +1335,17 @@ this call and must no longer be used directly by the application
 afterwards.
 
 @table @var
-@item daemon 
+@item daemon
 daemon that manages the connection
-@item client_socket 
+@item client_socket
 socket to manage (MHD will expect to receive an HTTP request from this socket next).
-@item addr 
+@item addr
 IP address of the client
-@item addrlen 
+@item addrlen
 number of bytes in addr
 @end table
 
-This function will return @code{MHD_YES} on success, 
+This function will return @code{MHD_YES} on success,
 @code{MHD_NO} if this daemon could
 not handle the connection (i.e. malloc failed, etc).
 The socket will be closed in any case; 'errno' is set
@@ -1387,7 +1384,7 @@ connection timeout is used).  The returned value is how long
 @code{select} should at most block, not the timeout value set for
 connections.  This function must not be called if the
 @code{MHD_USE_THREAD_PER_CONNECTION} mode is in use (since then it
-is not meaningful to ask for a timeout, after all, there is 
+is not meaningful to ask for a timeout, after all, there is
 concurrenct activity).  The function must also not be called by
 user-code if @code{MHD_USE_INTERNAL_SELECT} is in use.  In the latter
 case, the behavior is undefined.
@@ -1411,7 +1408,7 @@ right now).
 
 
 @deftypefun int MHD_get_connection_values (struct MHD_Connection *connection, enum MHD_ValueKind kind, MHD_KeyValueIterator iterator, void *iterator_cls)
-Get all the headers matching @var{kind} from the request.  
+Get all the headers matching @var{kind} from the request.
 
 The @var{iterator} callback is invoked once for each header, with
 @var{iterator_cls} as first argument.  After version 0.9.19, the
@@ -1439,9 +1436,9 @@ would contain the string ``key''.
 
 @deftypefun int MHD_set_connection_value (struct MHD_Connection *connection, enum MHD_ValueKind kind, const char * key, const char * value)
 This function can be used to append an entry to
-the list of HTTP headers of a connection (so that the 
+the list of HTTP headers of a connection (so that the
 @code{MHD_get_connection_values function} will return
-them -- and the MHD PostProcessor will also 
+them -- and the MHD PostProcessor will also
 see them).  This maybe required in certain
 situations (see Mantis #1399) where (broken)
 HTTP implementations fail to supply values needed
@@ -1457,11 +1454,11 @@ are NOT freed until the connection is closed.
 (The easiest way to do this is by passing only
 arguments to permanently allocated strings.).
 
-@var{connection} is the connection for which 
+@var{connection} is the connection for which
 the entry for @var{key} of the given @var{kind}
 should be set to the given @var{value}.
 
-The function returns @code{MHD_NO} if the operation 
+The function returns @code{MHD_NO} if the operation
 could not be performed due to insufficient memory
 and @code{MHD_YES} on success.
 @end deftypefun
@@ -1636,8 +1633,8 @@ size of the file)
 
 @item fd
 file descriptor referring to a file on disk with the data; will be
-closed when response is destroyed; note that 'fd' must be an actual 
-file descriptor (not a pipe or socket) since MHD might use 'sendfile' 
+closed when response is destroyed; note that 'fd' must be an actual
+file descriptor (not a pipe or socket) since MHD might use 'sendfile'
 or 'seek' on it.  The descriptor should be in blocking-IO mode.
 @end table
 
@@ -1678,8 +1675,8 @@ file starting at offset).
 
 @item fd
 file descriptor referring to a file on disk with the data; will be
-closed when response is destroyed; note that 'fd' must be an actual 
-file descriptor (not a pipe or socket) since MHD might use 'sendfile' 
+closed when response is destroyed; note that 'fd' must be an actual
+file descriptor (not a pipe or socket) since MHD might use 'sendfile'
 or 'seek' on it.    The descriptor should be in blocking-IO mode.
 
 @item offset
@@ -1701,8 +1698,8 @@ size of the data portion of the response;
 @item buffer
 the data itself;
 
-@item mode 
-memory management options for buffer; use 
+@item mode
+memory management options for buffer; use
 MHD_RESPMEM_PERSISTENT if the buffer is static/global memory,
 use MHD_RESPMEM_MUST_FREE if the buffer is heap-allocated and
 should be freed by MHD and MHD_RESPMEM_MUST_COPY if the
@@ -1779,7 +1776,7 @@ memory allocation error).
 @deftypefun int MHD_add_response_footer (struct MHD_Response *response, const char *footer, const char *content)
 Add a footer line to the response. The strings referenced by
 @var{footer} and @var{content} must be zero-terminated and they are
-duplicated into memory blocks embedded in @var{response}.  
+duplicated into memory blocks embedded in @var{response}.
 
 Notice that the strings must not hold newlines, carriage returns or tab
 chars.  You can add response footers at any time before signalling the
@@ -1833,6 +1830,72 @@ We should not modify the value, unless we know what we are doing.
 @c ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 @c ------------------------------------------------------------
+@node microhttpd-flow
+@chapter Flow control.
+
+@noindent
+Sometimes it may be possible that clients upload data faster
+than an application can process it, or that an application
+needs an extended period of time to generate a response.
+If @code{MHD_USE_THREAD_PER_CONNECTION} is used, applications
+can simply deal with this by performing their logic within the
+thread and thus effectively blocking connection processing
+by MHD.  In all other modes, blocking logic must not be
+placed within the callbacks invoked by MHD as this would also
+block processing of other requests, as a single thread may be
+responsible for tens of thousands of connections.
+
+Instead, applications using thread modes other than
+@code{MHD_USE_THREAD_PER_CONNECTION} should use the
+following functions to perform flow control.
+
+@deftypefun int MHD_suspend_connection (struct MHD_Connection *connection)
+Suspend handling of network data for a given connection.  This can
+be used to dequeue a connection from MHD's event loop (external
+select, internal select or thread pool; not applicable to
+thread-per-connection!) for a while.
+
+If you use this API in conjunction with a internal select or a
+thread pool, you must set the option @code{MHD_USE_PIPE_FOR_SHUTDOWN} to
+ensure that a resumed connection is immediately processed by MHD.
+
+Suspended connections continue to count against the total number of
+connections allowed (per daemon, as well as per IP, if such limits
+are set).  Suspended connections will NOT time out; timeouts will
+restart when the connection handling is resumed.  While a
+connection is suspended, MHD will not detect disconnects by the
+client.
+
+The only safe time to suspend a connection is from the
+@code{MHD_AccessHandlerCallback}.
+
+Finally, it is an API violation to call @code{MHD_stop_daemon} while
+having suspended connections (this will at least create memory and
+socket leaks or lead to undefined behavior).  You must explicitly
+resume all connections before stopping the daemon.
+
+@table @var
+@item connection
+the connection to suspend
+@end table
+@end deftypefun
+
+@deftypefun int MHD_resume_connection (struct MHD_Connection *connection)
+Resume handling of network data for suspended connection.  It is safe
+to resume a suspended connection at any time.  Calling this function
+on a connection that was not previously suspended will result in
+undefined behavior.
+
+@table @var
+@item connection
+the connection to resume
+@end table
+@end deftypefun
+
+
+@c ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+@c ------------------------------------------------------------
 @node microhttpd-dauth
 @chapter Utilizing Authentication
 
@@ -1960,41 +2023,41 @@ ahc_echo (void *cls,
   int ret;
 
   username = MHD_digest_auth_get_username(connection);
-  if (username == NULL) 
+  if (username == NULL)
     @{
-      response = MHD_create_response_from_buffer(strlen (DENIED), 
+      response = MHD_create_response_from_buffer(strlen (DENIED),
                                                  DENIED,
-                                                 MHD_RESPMEM_PERSISTENT);  
+                                                 MHD_RESPMEM_PERSISTENT);
       ret = MHD_queue_auth_fail_response(connection, realm,
                                          OPAQUE,
                                          response,
-                                         MHD_NO);    
-      MHD_destroy_response(response);  
+                                         MHD_NO);
+      MHD_destroy_response(response);
       return ret;
     @}
   ret = MHD_digest_auth_check(connection, realm,
-                              username, 
-                              password, 
+                              username,
+                              password,
                               300);
   free(username);
   if ( (ret == MHD_INVALID_NONCE) ||
        (ret == MHD_NO) )
     @{
-      response = MHD_create_response_from_buffer(strlen (DENIED), 
+      response = MHD_create_response_from_buffer(strlen (DENIED),
                                                  DENIED,
-                                                 MHD_RESPMEM_PERSISTENT);  
-      if (NULL == response) 
+                                                 MHD_RESPMEM_PERSISTENT);
+      if (NULL == response)
         return MHD_NO;
       ret = MHD_queue_auth_fail_response(connection, realm,
                                          OPAQUE,
                                          response,
-                                         (ret == MHD_INVALID_NONCE) ? MHD_YES : MHD_NO);  
-      MHD_destroy_response(response);  
+                                         (ret == MHD_INVALID_NONCE) ? MHD_YES : MHD_NO);
+      MHD_destroy_response(response);
       return ret;
     @}
   response = MHD_create_response_from_buffer (strlen(PAGE), PAGE,
                                               MHD_RESPMEM_PERSISTENT);
-  ret = MHD_queue_response(connection, MHD_HTTP_OK, response);  
+  ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
   MHD_destroy_response(response);
   return ret;
 @}
@@ -2026,7 +2089,7 @@ its @code{*@var{con_cls}} argument is set to @code{NULL}. When @code{POST}
 data comes in the upload buffer it is @strong{mandatory} to use the
 @var{con_cls} to store a reference to per-connection data.  The fact
 that the pointer was initially @code{NULL} can be used to detect that
-this is a new request.  
+this is a new request.
 
 One method to detect that a new connection was established is
 to set @code{*con_cls} to an unused integer:
@@ -2043,7 +2106,7 @@ access_handler (void *cls,
   static int old_connection_marker;
   int new_connection = (NULL == *con_cls);
 
-  if (new_connection) 
+  if (new_connection)
     @{
       /* new connection with POST */
       *con_cls = &old_connection_marker;
@@ -2070,13 +2133,13 @@ access_handler (void *cls,
 @{
   struct MHD_PostProcessor * pp = *con_cls;
 
-  if (pp == NULL) 
+  if (pp == NULL)
     @{
       pp = MHD_create_post_processor(connection, ...);
       *con_cls = pp;
       return MHD_YES;
     @}
-  if (*upload_data_size) 
+  if (*upload_data_size)
     @{
       MHD_post_process(pp, upload_data, *upload_data_size);
       *upload_data_size = 0;
@@ -2161,7 +2224,7 @@ is no special call to the iterator to indicate the end of the post processing
 stream.  After destroying the PostProcessor, the programmer should
 perform any necessary work to complete the processing of the iterator.
 
-Return @code{MHD_YES} if processing completed nicely, @code{MHD_NO} 
+Return @code{MHD_YES} if processing completed nicely, @code{MHD_NO}
 if there were spurious characters or formatting problems with
 the post request.  It is common to ignore the return value
 of this function.
@@ -2285,7 +2348,7 @@ connection is desired.
 @table @code
 
 @item MHD_CONNECTION_INFO_CIPHER_ALGO
-What cipher algorithm is being used (HTTPS connections only).  
+What cipher algorithm is being used (HTTPS connections only).
 Takes no extra arguments.
 @code{NULL} is returned for non-HTTPS connections.
 
@@ -2295,7 +2358,7 @@ Takes no extra arguments.   Allows finding out the TLS/SSL protocol used
 @code{NULL} is returned for non-HTTPS connections.
 
 @item MHD_CONNECTION_INFO_CLIENT_ADDRESS
-Returns information about the address of the client.  Returns 
+Returns information about the address of the client.  Returns
 essentially a @code{struct sockaddr **} (since the API returns
 a @code{union MHD_ConnectionInfo *} and that union contains
 a @code{struct sockaddr *}).
@@ -2303,7 +2366,7 @@ a @code{struct sockaddr *}).
 @item MHD_CONNECTION_INFO_GNUTLS_SESSION,
 Takes no extra arguments.  Allows access to the underlying GNUtls session,
 including access to the underlying GNUtls client certificate
-(HTTPS connections only).  Takes no extra arguments.  
+(HTTPS connections only).  Takes no extra arguments.
 @code{NULL} is returned for non-HTTPS connections.
 
 @item MHD_CONNECTION_INFO_GNUTLS_CLIENT_CERT,
@@ -2367,7 +2430,7 @@ connection should be changed.
 @item MHD_CONNECTION_OPTION_TIMEOUT
 Set a custom timeout for the given connection.   Specified
 as the number of seconds, given as an @code{unsigned int}.  Use
-zero for no timeout. 
+zero for no timeout.
 
 @end table
 @end deftp
diff --git a/src/include/microhttpd.h b/src/include/microhttpd.h
index c6828aa9..96dc2f27 100644
--- a/src/include/microhttpd.h
+++ b/src/include/microhttpd.h
@@ -42,7 +42,7 @@
  *
  * MHD understands POST data and is able to decode certain formats
  * (at the moment only "application/x-www-form-urlencoded" and
- * "mulitpart/formdata"). Unsupported encodings and large POST 
+ * "mulitpart/formdata"). Unsupported encodings and large POST
  * submissions may require the application to manually process
  * the stream, which is provided to the main application (and thus can be
  * processed, just not conveniently by MHD).
@@ -99,7 +99,7 @@ extern "C"
    hence works on any platform, we use "standard" includes here
    to build out-of-the-box for beginning users on common systems.
 
-   Once you have a proper build system and go for more exotic 
+   Once you have a proper build system and go for more exotic
    platforms, you should define MHD_PLATFORM_H in some header that
    you always include *before* "microhttpd.h".  Then the following
    "standard" includes won't be used (which might be a good
@@ -121,7 +121,7 @@ extern "C"
  * Current version of the library.
  * 0x01093001 = 1.9.30-1.
  */
-#define MHD_VERSION 0x00093100
+#define MHD_VERSION 0x00093101
 
 /**
  * MHD-internal return code for "YES".
@@ -254,7 +254,7 @@ extern "C"
  * SHOUTcast.  This will cause the response to begin
  * with the SHOUTcast "ICY" line instad of "HTTP".
  * @ingroup specialized
- */ 
+ */
 #define MHD_ICY_FLAG ((uint32_t)(1 << 31))
 
 /**
@@ -319,7 +319,7 @@ extern "C"
 /** @} */ /* end of group headers */
 
 /**
- * @defgroup versions HTTP versions 
+ * @defgroup versions HTTP versions
  * These strings should be used to match against the first line of the
  * HTTP header.
  * @{
@@ -367,7 +367,7 @@ struct MHD_Daemon;
  *
  * With HTTP/1.1, multiple requests can be run over the same
  * connection.  However, MHD will only show one request per TCP
- * connection to the client at any given time.  
+ * connection to the client at any given time.
  * @ingroup request
  */
 struct MHD_Connection;
@@ -386,7 +386,7 @@ struct MHD_PostProcessor;
 
 
 /**
- * @brief Flags for the `struct MHD_Daemon`. 
+ * @brief Flags for the `struct MHD_Daemon`.
  *
  * Note that if neither #MHD_USE_THREAD_PER_CONNECTION nor
  * #MHD_USE_SELECT_INTERNALLY is used, the client wants control over
@@ -476,7 +476,7 @@ enum MHD_FLAG
   MHD_USE_NO_LISTEN_SOCKET = 256,
 
   /**
-   * Use `epoll()` instead of `select()` or `poll()` for the event loop. 
+   * Use `epoll()` instead of `select()` or `poll()` for the event loop.
    * This option is only available on Linux; using the option on
    * non-Linux systems will cause #MHD_start_daemon to fail.
    */
@@ -611,9 +611,9 @@ enum MHD_OPTION
    * parsing will no longer contain the options, which maybe inconvenient for
    * logging.  This option should be followed by two arguments, the first
    * one must be of the form
-   * 
+   *
    *     void * my_logger(void *cls, const char *uri, struct MHD_Connection *con)
-   * 
+   *
    * where the return value will be passed as
    * (`* con_cls`) in calls to the #MHD_AccessHandlerCallback
    * when this request is processed later; returning a
@@ -675,7 +675,7 @@ enum MHD_OPTION
    * a function of type #MHD_LogCallback and the second a pointer
    * `void *` which will be passed as the first argument to the log
    * callback.
-   * 
+   *
    * Note that MHD will not generate any log messages
    * if it was compiled without the "--enable-messages"
    * flag being set.
@@ -696,7 +696,7 @@ enum MHD_OPTION
    * Additional options given in an array of `struct MHD_OptionItem`.
    * The array must be terminated with an entry `{MHD_OPTION_END, 0, NULL}`.
    * An example for code using #MHD_OPTION_ARRAY is:
-   * 
+   *
    *     struct MHD_OptionItem ops[] = {
    *       { MHD_OPTION_CONNECTION_LIMIT, 100, NULL },
    *       { MHD_OPTION_CONNECTION_TIMEOUT, 10, NULL },
@@ -705,7 +705,7 @@ enum MHD_OPTION
    *     d = MHD_start_daemon (0, 8080, NULL, NULL, dh, NULL,
    *                           MHD_OPTION_ARRAY, ops,
    *                           MHD_OPTION_END);
-   * 
+   *
    * For options that expect a single pointer argument, the
    * second member of the `struct MHD_OptionItem` is ignored.
    * For options that expect two pointer arguments, the first
@@ -721,7 +721,7 @@ enum MHD_OPTION
    * decodes escape sequences of the form "%HH".  This option should
    * be followed by two arguments, the first one must be of the form
    *
-   *     size_t my_unescaper(void *cls, 
+   *     size_t my_unescaper(void *cls,
    *                         struct MHD_Connection *c,
    *                         char *s)
    *
@@ -737,7 +737,7 @@ enum MHD_OPTION
    * Memory pointer for the random values to be used by the Digest
    * Auth module. This option should be followed by two arguments.
    * First an integer of type  `size_t` which specifies the size
-   * of the buffer pointed to by the second argument in bytes.  
+   * of the buffer pointed to by the second argument in bytes.
    * Note that the application must ensure that the buffer of the
    * second argument remains allocated and unmodified while the
    * deamon is running.
@@ -919,7 +919,7 @@ union MHD_ConnectionInfo
   int /* enum gnutls_protocol */ protocol;
 
   /**
-   * Connect socket 
+   * Connect socket
    */
   int connect_fd;
 
@@ -1046,7 +1046,7 @@ enum MHD_DaemonInfoType
  * @param reason error detail, may be NULL
  * @ingroup logging
  */
-typedef 
+typedef
   void (*MHD_PanicCallback) (void *cls,
                              const char *file,
                              unsigned int line,
@@ -1076,7 +1076,7 @@ typedef int
  * @param cls argument given together with the function
  *        pointer when the handler was registered with MHD
  * @param url the requested url
- * @param method the HTTP method used (#MHD_HTTP_METHOD_GET, 
+ * @param method the HTTP method used (#MHD_HTTP_METHOD_GET,
  *        #MHD_HTTP_METHOD_PUT, etc.)
  * @param version the HTTP version string (i.e.
  *        #MHD_HTTP_VERSION_1_1)
@@ -1157,12 +1157,9 @@ typedef int
  * total number of bytes that has been placed into @a buf should be
  * returned.
  *
- * Note that returning zero will cause libmicrohttpd to try again,
- * either "immediately" if in multi-threaded mode (in which case the
- * callback may want to do blocking operations) or in the next round
- * if #MHD_run is used.  Returning 0 for a daemon that runs in internal
- * select mode is an error (since it would result in busy waiting) and
- * will cause the program to be aborted (via `abort()`).
+ * Note that returning zero will cause libmicrohttpd to try again.
+ * Thus, returning zero should only be used in conjunction
+ * with MHD_suspend_connection() to avoid busy waiting.
  *
  * @param cls extra argument to the callback
  * @param pos position in the datastream to access;
@@ -1175,7 +1172,7 @@ typedef int
  *        obtained from the content reader so far.
  * @param buf where to copy the data
  * @param max maximum number of bytes to copy to @a buf (size of @a buf)
- * @return number of bytes written to @a buf; 
+ * @return number of bytes written to @a buf;
  *  0 is legal unless we are running in internal select mode (since
  *    this would cause busy-waiting); 0 in external select mode
  *    will cause this function to be called again once the external
@@ -1183,7 +1180,7 @@ typedef int
  *  #MHD_CONTENT_READER_END_OF_STREAM (-1) for the regular
  *    end of transmission (with chunked encoding, MHD will then
  *    terminate the chunk and send any HTTP footers that might be
- *    present; without chunked encoding and given an unknown 
+ *    present; without chunked encoding and given an unknown
  *    response size, MHD will simply close the connection; note
  *    that while returning #MHD_CONTENT_READER_END_OF_STREAM is not technically
  *    legal if a response size was specified, MHD accepts this
@@ -1214,7 +1211,7 @@ typedef ssize_t
  * @param cls closure
  * @ingroup response
  */
-typedef void 
+typedef void
   (*MHD_ContentReaderFreeCallback) (void *cls);
 
 
@@ -1244,8 +1241,8 @@ typedef int
                            const char *filename,
                            const char *content_type,
                            const char *transfer_encoding,
-                           const char *data, 
-                           uint64_t off, 
+                           const char *data,
+                           uint64_t off,
                            size_t size);
 
 /* **************** Daemon handling functions ***************** */
@@ -1271,7 +1268,7 @@ struct MHD_Daemon *
 MHD_start_daemon_va (unsigned int flags,
                      uint16_t port,
                      MHD_AcceptPolicyCallback apc, void *apc_cls,
-                     MHD_AccessHandlerCallback dh, void *dh_cls, 
+                     MHD_AccessHandlerCallback dh, void *dh_cls,
                      va_list ap);
 
 
@@ -1295,7 +1292,7 @@ struct MHD_Daemon *
 MHD_start_daemon (unsigned int flags,
                   uint16_t port,
                   MHD_AcceptPolicyCallback apc, void *apc_cls,
-                  MHD_AccessHandlerCallback dh, void *dh_cls, 
+                  MHD_AccessHandlerCallback dh, void *dh_cls,
                   ...);
 
 
@@ -1314,7 +1311,7 @@ MHD_start_daemon (unsigned int flags,
  * #MHD_start_daemon, this function will return -1.
  *
  * @param daemon daemon to stop accepting new connections for
- * @return old listen socket on success, -1 if the daemon was 
+ * @return old listen socket on success, -1 if the daemon was
  *         already not listening anymore
  * @ingroup specialized
  */
@@ -1328,7 +1325,7 @@ MHD_quiesce_daemon (struct MHD_Daemon *daemon);
  * @param daemon daemon to stop
  * @ingroup event
  */
-void 
+void
 MHD_stop_daemon (struct MHD_Daemon *daemon);
 
 
@@ -1361,8 +1358,8 @@ MHD_stop_daemon (struct MHD_Daemon *daemon);
  *        set to indicate further details about the error.
  * @ingroup specialized
  */
-int 
-MHD_add_connection (struct MHD_Daemon *daemon, 
+int
+MHD_add_connection (struct MHD_Daemon *daemon,
                     int client_socket,
                     const struct sockaddr *addr,
                     socklen_t addrlen);
@@ -1385,8 +1382,8 @@ MHD_add_connection (struct MHD_Daemon *daemon,
 int
 MHD_get_fdset (struct MHD_Daemon *daemon,
                fd_set *read_fd_set,
-               fd_set *write_fd_set, 
-               fd_set *except_fd_set, 
+               fd_set *write_fd_set,
+               fd_set *except_fd_set,
                int *max_fd);
 
 
@@ -1404,8 +1401,8 @@ MHD_get_fdset (struct MHD_Daemon *daemon,
  *        necessiate the use of a timeout right now).
  * @ingroup event
  */
-int 
-MHD_get_timeout (struct MHD_Daemon *daemon, 
+int
+MHD_get_timeout (struct MHD_Daemon *daemon,
                  MHD_UNSIGNED_LONG_LONG *timeout);
 
 
@@ -1428,7 +1425,7 @@ MHD_get_timeout (struct MHD_Daemon *daemon,
  *         options for this call.
  * @ingroup event
  */
-int 
+int
 MHD_run (struct MHD_Daemon *daemon);
 
 
@@ -1452,7 +1449,7 @@ MHD_run (struct MHD_Daemon *daemon);
  * @ingroup event
  */
 int
-MHD_run_from_select (struct MHD_Daemon *daemon, 
+MHD_run_from_select (struct MHD_Daemon *daemon,
                      const fd_set *read_fd_set,
                      const fd_set *write_fd_set,
                      const fd_set *except_fd_set);
@@ -1486,7 +1483,7 @@ MHD_get_connection_values (struct MHD_Connection *connection,
  * them).  This maybe required in certain situations (see Mantis
  * #1399) where (broken) HTTP implementations fail to supply values
  * needed by the post processor (or other parts of the application).
- * 
+ *
  * This function MUST only be called from within the
  * #MHD_AccessHandlerCallback (otherwise, access maybe improperly
  * synchronized).  Furthermore, the client must guarantee that the key
@@ -1507,7 +1504,7 @@ MHD_get_connection_values (struct MHD_Connection *connection,
 int
 MHD_set_connection_value (struct MHD_Connection *connection,
                           enum MHD_ValueKind kind,
-                          const char *key, 
+                          const char *key,
                           const char *value);
 
 
@@ -1527,7 +1524,7 @@ MHD_set_connection_value (struct MHD_Connection *connection,
  * @param cls passed to @a cb
  * @ingroup logging
  */
-void 
+void
 MHD_set_panic_func (MHD_PanicCallback cb, void *cls);
 
 
@@ -1560,10 +1557,53 @@ MHD_lookup_connection_value (struct MHD_Connection *connection,
  */
 int
 MHD_queue_response (struct MHD_Connection *connection,
-                    unsigned int status_code, 
+                    unsigned int status_code,
                     struct MHD_Response *response);
 
 
+/**
+ * Suspend handling of network data for a given connection.  This can
+ * be used to dequeue a connection from MHD's event loop (external
+ * select, internal select or thread pool; not applicable to
+ * thread-per-connection!) for a while.
+ *
+ * If you use this API in conjunction with a internal select or a
+ * thread pool, you must set the option #MHD_USE_PIPE_FOR_SHUTDOWN to
+ * ensure that a resumed connection is immediately processed by MHD.
+ *
+ * Suspended connections continue to count against the total number of
+ * connections allowed (per daemon, as well as per IP, if such limits
+ * are set).  Suspended connections will NOT time out; timeouts will
+ * restart when the connection handling is resumed.  While a
+ * connection is suspended, MHD will not detect disconnects by the
+ * client.
+ *
+ * The only safe time to suspend a connection is from the
+ * #MHD_AccessHandlerCallback.
+ *
+ * Finally, it is an API violation to call #MHD_stop_daemon while
+ * having suspended connections (this will at least create memory and
+ * socket leaks or lead to undefined behavior).  You must explicitly
+ * resume all connections before stopping the daemon.
+ *
+ * @param connection the connection to suspend
+ */
+void
+MHD_suspend_connection (struct MHD_Connection *connection);
+
+
+/**
+ * Resume handling of network data for suspended connection.  It is
+ * safe to resume a suspended connection at any time.  Calling this
+ * function on a connection that was not previously suspended will
+ * result in undefined behavior.
+ *
+ * @param connection the connection to resume
+ */
+void
+MHD_resume_connection (struct MHD_Connection *connection);
+
+
 /* **************** Response manipulation functions ***************** */
 
 /**
@@ -1615,7 +1655,7 @@ MHD_create_response_from_data (size_t size,
  * given for the response.
  * @ingroup response
  */
-enum MHD_ResponseMemoryMode 
+enum MHD_ResponseMemoryMode
 {
 
   /**
@@ -1667,7 +1707,7 @@ MHD_create_response_from_buffer (size_t size,
  * header information and then be used any number of times.
  *
  * @param size size of the data portion of the response
- * @param fd file descriptor referring to a file on disk with the 
+ * @param fd file descriptor referring to a file on disk with the
  *        data; will be closed when response is destroyed;
  *        fd should be in 'blocking' mode
  * @return NULL on error (i.e. invalid arguments, out of memory)
@@ -1687,7 +1727,7 @@ MHD_create_response_from_fd (size_t size,
  *        data; will be closed when response is destroyed;
  *        fd should be in 'blocking' mode
  * @param offset offset to start reading from in the file;
- *        Be careful! `off_t` may have been compiled to be a 
+ *        Be careful! `off_t` may have been compiled to be a
  *        64-bit variable for MHD, in which case your application
  *        also has to be compiled using the same options! Read
  *        the MHD manual for more details.
@@ -1705,7 +1745,7 @@ MHD_create_response_from_fd_at_offset (size_t size,
  * Bits in an event mask that specifies which actions
  * MHD should perform and under which conditions it
  * should call the 'upgrade' callback again.
- */ 
+ */
 enum MHD_UpgradeEventMask
 {
 
@@ -1731,7 +1771,7 @@ enum MHD_UpgradeEventMask
    * Do not wait on any socket actions, we're waiting on
    * an 'external' event.  Run the function again once
    * the 'select' call returns _without_ this socket even
-   * being involved in the select sets (useful in 
+   * being involved in the select sets (useful in
    * conjunction with the external select loop).
    */
   MHD_UPGRADE_EVENT_EXTERNAL = 4,
@@ -1743,15 +1783,15 @@ enum MHD_UpgradeEventMask
    * may ignore if the platform does not support it).  Note that
    * only returning 'CORK' will *also* cause the socket to be closed!
    */
-  MHD_UPGRADE_EVENT_CORK = 8  
-    
+  MHD_UPGRADE_EVENT_CORK = 8
+
 };
 
 
 /**
  * Function called after a protocol "upgrade" response was sent
  * successfully and the socket should now be controlled by some
- * protocol other than HTTP. 
+ * protocol other than HTTP.
  *
  * Any data received on the socket will be made available in
  * 'data_in'.  The function should update 'data_in_size' to
@@ -1786,7 +1826,7 @@ enum MHD_UpgradeEventMask
  *                be also given to the #MHD_RequestCompletedCallback
  * @param data_in_size available data for reading, set to data read
  * @param data_in data read from the socket
- * @param data_out_size available buffer for writing, set to bytes 
+ * @param data_out_size available buffer for writing, set to bytes
  *                written to 'data_out'
  * @param data_out buffer for sending data via the connection
  * @return desired actions for event handling loop
@@ -1843,7 +1883,7 @@ MHD_create_response_for_upgrade (MHD_UpgradeHandler upgrade_handler,
  * @param response response to destroy
  * @ingroup response
  */
-void 
+void
 MHD_destroy_response (struct MHD_Response *response);
 
 
@@ -1874,7 +1914,7 @@ MHD_add_response_header (struct MHD_Response *response,
  */
 int
 MHD_add_response_footer (struct MHD_Response *response,
-                         const char *footer, 
+                         const char *footer,
                          const char *content);
 
 
@@ -1889,7 +1929,7 @@ MHD_add_response_footer (struct MHD_Response *response,
  */
 int
 MHD_del_response_header (struct MHD_Response *response,
-                         const char *header, 
+                         const char *header,
                          const char *content);
 
 
@@ -1982,7 +2022,7 @@ MHD_post_process (struct MHD_PostProcessor *pp,
  *                value of this function
  * @ingroup request
  */
-int 
+int
 MHD_destroy_post_processor (struct MHD_PostProcessor *pp);
 
 
@@ -2098,7 +2138,7 @@ MHD_queue_basic_auth_fail_response (struct MHD_Connection *connection,
  */
 const union MHD_ConnectionInfo *
 MHD_get_connection_info (struct MHD_Connection *connection,
-                         enum MHD_ConnectionInfoType info_type, 
+                         enum MHD_ConnectionInfoType info_type,
                          ...);
 
 
@@ -2128,11 +2168,11 @@ enum MHD_CONNECTION_OPTION
  * @return #MHD_YES on success, #MHD_NO if setting the option failed
  * @ingroup specialized
  */
-int 
+int
 MHD_set_connection_option (struct MHD_Connection *connection,
                            enum MHD_CONNECTION_OPTION option,
                            ...);
-                           
+
 
 /**
  * Information about an MHD daemon.
@@ -2171,7 +2211,7 @@ union MHD_DaemonInfo
  */
 const union MHD_DaemonInfo *
 MHD_get_daemon_info (struct MHD_Daemon *daemon,
-                     enum MHD_DaemonInfoType info_type, 
+                     enum MHD_DaemonInfoType info_type,
                      ...);
 
 
@@ -2181,7 +2221,7 @@ MHD_get_daemon_info (struct MHD_Daemon *daemon,
  * @return static version string, e.g. "0.9.9"
  * @ingroup specialized
  */
-const char* 
+const char*
 MHD_get_version (void);
 
 
diff --git a/src/microhttpd/EXPORT.sym b/src/microhttpd/EXPORT.sym
index dc32b6d3..402a0ef3 100644
--- a/src/microhttpd/EXPORT.sym
+++ b/src/microhttpd/EXPORT.sym
@@ -35,3 +35,5 @@ MHD_basic_auth_get_username_password
 MHD_queue_basic_auth_fail_response
 MHD_add_connection
 MHD_set_connection_option
+MHD_suspend_connection
+MHD_resume_connection
diff --git a/src/microhttpd/connection.c b/src/microhttpd/connection.c
index 6190fc29..63df4b94 100644
--- a/src/microhttpd/connection.c
+++ b/src/microhttpd/connection.c
@@ -148,7 +148,7 @@ MHD_get_connection_values (struct MHD_Connection *connection,
  * them).  This maybe required in certain situations (see Mantis
  * #1399) where (broken) HTTP implementations fail to supply values
  * needed by the post processor (or other parts of the application).
- * 
+ *
  * This function MUST only be called from within the
  * #MHD_AccessHandlerCallback (otherwise, access maybe improperly
  * synchronized).  Furthermore, the client must guarantee that the key
@@ -215,12 +215,12 @@ MHD_lookup_connection_value (struct MHD_Connection *connection,
   if (NULL == connection)
     return NULL;
   for (pos = connection->headers_received; NULL != pos; pos = pos->next)
-    if ((0 != (pos->kind & kind)) && 
+    if ((0 != (pos->kind & kind)) &&
         ( (key == pos->header) ||
           ( (NULL != pos->header) &&
             (NULL != key) &&
             (0 == strcasecmp (key, pos->header))) ))
-      return pos->value;    
+      return pos->value;
   return NULL;
 }
 
@@ -265,13 +265,13 @@ MHD_connection_close (struct MHD_Connection *connection,
 
   daemon = connection->daemon;
   if (0 == (connection->daemon->options & MHD_USE_EPOLL_TURBO))
-    SHUTDOWN (connection->socket_fd, 
+    SHUTDOWN (connection->socket_fd,
               (MHD_YES == connection->read_closed) ? SHUT_WR : SHUT_RDWR);
   connection->state = MHD_CONNECTION_CLOSED;
   connection->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
   if ( (NULL != daemon->notify_completed) &&
        (MHD_YES == connection->client_aware) )
-    daemon->notify_completed (daemon->notify_completed_cls, 
+    daemon->notify_completed (daemon->notify_completed_cls,
                               connection,
                               &connection->client_context,
                               termination_code);
@@ -342,25 +342,16 @@ try_ready_normal_body (struct MHD_Connection *connection)
        (0 == (connection->daemon->options & MHD_USE_SSL)) )
     {
       /* will use sendfile, no need to bother response crc */
-      return MHD_YES; 
+      return MHD_YES;
     }
 #endif
-  
+
   ret = response->crc (response->crc_cls,
                        connection->response_write_position,
                        response->data,
                        MHD_MIN (response->data_buffer_size,
                                 response->total_size -
                                 connection->response_write_position));
-  if ((0 == ret) &&
-      (0 != (connection->daemon->options & MHD_USE_SELECT_INTERNALLY)))
-    mhd_panic (mhd_panic_cls, __FILE__, __LINE__
-#if HAVE_MESSAGES
-               , "API violation"
-#else
-               , NULL
-#endif
-               );
   if ( (MHD_CONTENT_READER_END_OF_STREAM == ret) ||
        (MHD_CONTENT_READER_END_WITH_ERROR == ret) )
     {
@@ -368,7 +359,7 @@ try_ready_normal_body (struct MHD_Connection *connection)
       response->total_size = connection->response_write_position;
       if (NULL != response->crc)
         pthread_mutex_unlock (&response->mutex);
-      if (MHD_CONTENT_READER_END_OF_STREAM == ret) 
+      if (MHD_CONTENT_READER_END_OF_STREAM == ret)
         MHD_connection_close (connection, MHD_REQUEST_TERMINATED_COMPLETED_OK);
       else
         CONNECTION_CLOSE_ERROR (connection,
@@ -470,14 +461,14 @@ try_ready_chunked_body (struct MHD_Connection *connection)
       response->total_size = connection->response_write_position;
       return MHD_YES;
     }
-  if (0 == ret) 
+  if (0 == ret)
     {
       connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY;
       return MHD_NO;
     }
   if (ret > 0xFFFFFF)
     ret = 0xFFFFFF;
-  snprintf (cbuf, 
+  snprintf (cbuf,
             sizeof (cbuf),
             "%X\r\n", (unsigned int) ret);
   cblen = strlen (cbuf);
@@ -528,7 +519,7 @@ add_extra_headers (struct MHD_Connection *connection)
              if the client asked for a close, no need to start chunk'ing */
           if ((NULL == client_close) &&
               (NULL != connection->version) &&
-              (0 == strcasecmp (connection->version, MHD_HTTP_VERSION_1_1))) 
+              (0 == strcasecmp (connection->version, MHD_HTTP_VERSION_1_1)))
             {
               connection->have_chunked_upload = MHD_YES;
               have_encoding = MHD_get_response_header (connection->response,
@@ -562,17 +553,17 @@ add_extra_headers (struct MHD_Connection *connection)
                                MHD_HTTP_METHOD_CONNECT)) ||
              (0 != connection->response->total_size) ) )
         {
-          /* 
+          /*
              Here we add a content-length if one is missing; however,
-             for 'connect' methods, the responses MUST NOT include a 
+             for 'connect' methods, the responses MUST NOT include a
              content-length header *if* the response code is 2xx (in
              which case we expect there to be no body).  Still,
-             as we don't know the response code here in some cases, we 
+             as we don't know the response code here in some cases, we
              simply only force adding a content-length header if this
              is not a 'connect' or if the response is not empty
              (which is kind of more sane, because if some crazy
              application did return content with a 2xx status code,
-             then having a content-length might again be a good idea). 
+             then having a content-length might again be a good idea).
 
              Note that the change from 'SHOULD NOT' to 'MUST NOT' is
              a recent development of the HTTP 1.1 specification.
@@ -616,8 +607,8 @@ get_date_string (char *date)
            (unsigned int) now.tm_mday,
            mons[now.tm_mon % 12],
            (unsigned int) (1900 + now.tm_year),
-           (unsigned int) now.tm_hour, 
-           (unsigned int) now.tm_min, 
+           (unsigned int) now.tm_hour,
+           (unsigned int) now.tm_min,
            (unsigned int) now.tm_sec);
 }
 
@@ -626,7 +617,7 @@ get_date_string (char *date)
  * Try growing the read buffer.  We initially claim half the
  * available buffer space for the read buffer (the other half
  * being left for management data structures; the write
- * buffer can in the end take virtually everything as the 
+ * buffer can in the end take virtually everything as the
  * read buffer can be reduced to the minimum necessary at that
  * point.
  *
@@ -696,18 +687,18 @@ build_header_response (struct MHD_Connection *connection)
       SPRINTF (code,
                "%s %u %s\r\n",
                (0 != (connection->responseCode & MHD_ICY_FLAG))
-               ? "ICY" 
+               ? "ICY"
                : ( (0 == strcasecmp (MHD_HTTP_VERSION_1_0,
-                                     connection->version)) 
-                   ? MHD_HTTP_VERSION_1_0 
+                                     connection->version))
+                   ? MHD_HTTP_VERSION_1_0
                    : MHD_HTTP_VERSION_1_1),
-               rc, 
+               rc,
                reason_phrase);
       off = strlen (code);
       /* estimate size */
       size = off + 2;           /* extra \r\n at the end */
       kind = MHD_HEADER_KIND;
-      if ( (0 == (connection->daemon->options & MHD_SUPPRESS_DATE_NO_CLOCK)) && 
+      if ( (0 == (connection->daemon->options & MHD_SUPPRESS_DATE_NO_CLOCK)) &&
            (NULL == MHD_get_response_header (connection->response,
                                              MHD_HTTP_HEADER_DATE)) )
         get_date_string (date);
@@ -757,9 +748,9 @@ build_header_response (struct MHD_Connection *connection)
     }
   for (pos = connection->response->first_header; NULL != pos; pos = pos->next)
     if (pos->kind == kind)
-      off += SPRINTF (&data[off], 
+      off += SPRINTF (&data[off],
                       "%s: %s\r\n",
-                      pos->header, 
+                      pos->header,
                       pos->value);
   if (connection->state == MHD_CONNECTION_FOOTERS_RECEIVED)
     {
@@ -790,7 +781,7 @@ build_header_response (struct MHD_Connection *connection)
  */
 static void
 transmit_error_response (struct MHD_Connection *connection,
-                         unsigned int status_code, 
+                         unsigned int status_code,
                          const char *message)
 {
   struct MHD_Response *response;
@@ -810,7 +801,7 @@ transmit_error_response (struct MHD_Connection *connection,
 #endif
   EXTRA_CHECK (NULL == connection->response);
   response = MHD_create_response_from_buffer (strlen (message),
-                                              (void *) message, 
+                                              (void *) message,
                                               MHD_RESPMEM_PERSISTENT);
   MHD_queue_response (connection, status_code, response);
   EXTRA_CHECK (NULL != connection->response);
@@ -834,7 +825,7 @@ transmit_error_response (struct MHD_Connection *connection,
  * perform other updates to the connection if needed to prepare for
  * the next round of the event loop.
  *
- * @param connection connetion to get poll set for 
+ * @param connection connetion to get poll set for
  */
 static void
 MHD_connection_update_event_loop_info (struct MHD_Connection *connection)
@@ -847,7 +838,7 @@ MHD_connection_update_event_loop_info (struct MHD_Connection *connection)
 #endif
       switch (connection->state)
         {
-#if HTTPS_SUPPORT     
+#if HTTPS_SUPPORT
         case MHD_TLS_CONNECTION_INIT:
           if (0 == gnutls_record_get_direction (connection->tls_session))
             connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
@@ -921,7 +912,7 @@ MHD_connection_update_event_loop_info (struct MHD_Connection *connection)
              read buffer if needed, no size-check required */
           if (MHD_YES == connection->read_closed)
             {
-              CONNECTION_CLOSE_ERROR (connection, 
+              CONNECTION_CLOSE_ERROR (connection,
                                       NULL);
               continue;
             }
@@ -1000,7 +991,7 @@ get_next_header_line (struct MHD_Connection *connection)
     {
       /* not found, consider growing... */
       if ( (connection->read_buffer_offset == connection->read_buffer_size) &&
-           (MHD_NO == 
+           (MHD_NO ==
             try_grow_read_buffer (connection)) )
         {
           transmit_error_response (connection,
@@ -1008,7 +999,7 @@ get_next_header_line (struct MHD_Connection *connection)
                                    ? MHD_HTTP_REQUEST_ENTITY_TOO_LARGE
                                    : MHD_HTTP_REQUEST_URI_TOO_LONG,
                                    REQUEST_TOO_BIG);
-        }        
+        }
       return NULL;
     }
   /* found, check if we have proper LFCR */
@@ -1064,7 +1055,7 @@ connection_add_header (struct MHD_Connection *connection,
  */
 static int
 parse_arguments (enum MHD_ValueKind kind,
-                 struct MHD_Connection *connection, 
+                 struct MHD_Connection *connection,
                  char *args)
 {
   char *equals;
@@ -1086,7 +1077,7 @@ parse_arguments (enum MHD_ValueKind kind,
               return connection_add_header (connection,
                                             args,
                                             NULL,
-                                            kind);            
+                                            kind);
             }
           /* got 'foo=bar' */
           equals[0] = '\0';
@@ -1261,7 +1252,7 @@ parse_initial_message_line (struct MHD_Connection *connection, char *line)
     }
   if (NULL != connection->daemon->uri_log_callback)
     connection->client_context
-      = connection->daemon->uri_log_callback (connection->daemon->uri_log_callback_cls, 
+      = connection->daemon->uri_log_callback (connection->daemon->uri_log_callback_cls,
                                               uri,
                                               connection);
   args = strchr (uri, '?');
@@ -1296,7 +1287,7 @@ call_connection_handler (struct MHD_Connection *connection)
   size_t processed;
 
   if (NULL != connection->response)
-    return;                     /* already queued a response */  
+    return;                     /* already queued a response */
   processed = 0;
   connection->client_aware = MHD_YES;
   if (MHD_NO ==
@@ -1309,7 +1300,7 @@ call_connection_handler (struct MHD_Connection *connection)
                                            &connection->client_context))
     {
       /* serious internal error, close connection */
-      CONNECTION_CLOSE_ERROR (connection, 
+      CONNECTION_CLOSE_ERROR (connection,
                               "Internal application error, closing connection.\n");
       return;
     }
@@ -1438,7 +1429,7 @@ process_request_body (struct MHD_Connection *connection)
       else
         {
           /* no chunked encoding, give all to the client */
-          if ( (0 != connection->remaining_upload_size) && 
+          if ( (0 != connection->remaining_upload_size) &&
                (MHD_SIZE_UNKNOWN != connection->remaining_upload_size) &&
                (connection->remaining_upload_size < available) )
             {
@@ -1527,7 +1518,7 @@ do_read (struct MHD_Connection *connection)
                   "Failed to receive data: %s\n",
                   gnutls_strerror (bytes_read));
       else
-#endif      
+#endif
         MHD_DLOG (connection->daemon,
                   "Failed to receive data: %s\n", STRERROR (errno));
 #endif
@@ -1577,7 +1568,7 @@ do_write (struct MHD_Connection *connection)
                   "Failed to send data: %s\n",
                   gnutls_strerror (ret));
       else
-#endif      
+#endif
         MHD_DLOG (connection->daemon,
                   "Failed to send data: %s\n", STRERROR (errno));
 #endif
@@ -1613,7 +1604,7 @@ check_write_done (struct MHD_Connection *connection,
   connection->write_buffer_append_offset = 0;
   connection->write_buffer_send_offset = 0;
   connection->state = next_state;
-  MHD_pool_reallocate (connection->pool, 
+  MHD_pool_reallocate (connection->pool,
                        connection->write_buffer,
                        connection->write_buffer_size, 0);
   connection->write_buffer = NULL;
@@ -1641,7 +1632,7 @@ process_header_line (struct MHD_Connection *connection, char *line)
   if (NULL == colon)
     {
       /* error in header line, die hard */
-      CONNECTION_CLOSE_ERROR (connection, 
+      CONNECTION_CLOSE_ERROR (connection,
                               "Received malformed line (no colon), closing connection.\n");
       return MHD_NO;
     }
@@ -1689,7 +1680,7 @@ process_broken_line (struct MHD_Connection *connection,
       /* skip whitespace at start of 2nd line */
       tmp = line;
       while ((tmp[0] == ' ') || (tmp[0] == '\t'))
-        tmp++;                  
+        tmp++;
       tmp_len = strlen (tmp);
       /* FIXME: we might be able to do this better (faster!), as most
          likely 'last' and 'line' should already be adjacent in
@@ -1833,7 +1824,7 @@ update_last_activity (struct MHD_Connection *connection)
   /* move connection to head of timeout list (by remove + add operation) */
   if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
        (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )
-    MHD_PANIC ("Failed to acquire cleanup mutex\n");    
+    MHD_PANIC ("Failed to acquire cleanup mutex\n");
   XDLL_remove (daemon->normal_timeout_head,
                daemon->normal_timeout_tail,
                connection);
@@ -1842,13 +1833,13 @@ update_last_activity (struct MHD_Connection *connection)
                connection);
   if  ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
         (0 != pthread_mutex_unlock (&daemon->cleanup_connection_mutex)) )
-    MHD_PANIC ("Failed to release cleanup mutex\n");    
+    MHD_PANIC ("Failed to release cleanup mutex\n");
 }
 
 
 /**
  * This function handles a particular connection when it has been
- * determined that there is data to be read off a socket. 
+ * determined that there is data to be read off a socket.
  *
  * @param connection connection to handle
  * @return always #MHD_YES (we should continue to process the
@@ -1982,10 +1973,10 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
           break;
         case MHD_CONNECTION_NORMAL_BODY_READY:
           response = connection->response;
-          if (response->crc != NULL)
+          if (NULL != response->crc)
             pthread_mutex_lock (&response->mutex);
-          if (MHD_YES != try_ready_normal_body (connection))            
-            break;            
+          if (MHD_YES != try_ready_normal_body (connection))
+            break;
           ret = connection->send_cls (connection,
                                       &response->data
                                       [connection->response_write_position
@@ -2001,7 +1992,7 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
                      &response->data[connection->response_write_position -
                                      response->data_start]);
 #endif
-          if (response->crc != NULL)
+          if (NULL != response->crc)
             pthread_mutex_unlock (&response->mutex);
           if (ret < 0)
             {
@@ -2078,8 +2069,8 @@ cleanup_connection (struct MHD_Connection *connection)
       connection->response = NULL;
     }
   if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
-       (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )          
-    MHD_PANIC ("Failed to acquire cleanup mutex\n");            
+       (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )
+    MHD_PANIC ("Failed to acquire cleanup mutex\n");
   if (connection->connection_timeout == daemon->connection_timeout)
     XDLL_remove (daemon->normal_timeout_head,
                  daemon->normal_timeout_tail,
@@ -2095,15 +2086,15 @@ cleanup_connection (struct MHD_Connection *connection)
               daemon->cleanup_tail,
               connection);
   if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
-       (0 != pthread_mutex_unlock(&daemon->cleanup_connection_mutex)) )         
-    MHD_PANIC ("Failed to release cleanup mutex\n");        
+       (0 != pthread_mutex_unlock(&daemon->cleanup_connection_mutex)) )
+    MHD_PANIC ("Failed to release cleanup mutex\n");
   connection->in_idle = MHD_NO;
 }
 
 
 /**
  * This function was created to handle per-connection processing that
- * has to happen even if the socket cannot be read or written to. 
+ * has to happen even if the socket cannot be read or written to.
  *
  * @param connection connection to handle
  * @return #MHD_YES if we should continue to process the
@@ -2135,7 +2126,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
                 continue;
               if (MHD_YES == connection->read_closed)
                 {
-                  CONNECTION_CLOSE_ERROR (connection, 
+                  CONNECTION_CLOSE_ERROR (connection,
                                           NULL);
                   continue;
                 }
@@ -2154,7 +2145,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
                 continue;
               if (MHD_YES == connection->read_closed)
                 {
-                  CONNECTION_CLOSE_ERROR (connection, 
+                  CONNECTION_CLOSE_ERROR (connection,
                                           NULL);
                   continue;
                 }
@@ -2182,7 +2173,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
                 continue;
               if (MHD_YES == connection->read_closed)
                 {
-                  CONNECTION_CLOSE_ERROR (connection, 
+                  CONNECTION_CLOSE_ERROR (connection,
                                           NULL);
                   continue;
                 }
@@ -2262,7 +2253,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
                 continue;
               if (MHD_YES == connection->read_closed)
                 {
-                  CONNECTION_CLOSE_ERROR (connection, 
+                  CONNECTION_CLOSE_ERROR (connection,
                                           NULL);
                   continue;
                 }
@@ -2290,7 +2281,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
                 continue;
               if (MHD_YES == connection->read_closed)
                 {
-                  CONNECTION_CLOSE_ERROR (connection, 
+                  CONNECTION_CLOSE_ERROR (connection,
                                           NULL);
                   continue;
                 }
@@ -2314,7 +2305,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
           if (MHD_NO == build_header_response (connection))
             {
               /* oops - close! */
-              CONNECTION_CLOSE_ERROR (connection, 
+              CONNECTION_CLOSE_ERROR (connection,
                                       "Closing connection (failed to create response header)\n");
               continue;
             }
@@ -2342,11 +2333,11 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
           /* nothing to do here */
           break;
         case MHD_CONNECTION_NORMAL_BODY_UNREADY:
-          if (connection->response->crc != NULL)
+          if (NULL != connection->response->crc)
             pthread_mutex_lock (&connection->response->mutex);
           if (0 == connection->response->total_size)
             {
-              if (connection->response->crc != NULL)
+              if (NULL != connection->response->crc)
                 pthread_mutex_unlock (&connection->response->mutex);
               connection->state = MHD_CONNECTION_BODY_SENT;
               continue;
@@ -2364,23 +2355,23 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
           /* nothing to do here */
           break;
         case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
-          if (connection->response->crc != NULL)
+          if (NULL != connection->response->crc)
             pthread_mutex_lock (&connection->response->mutex);
           if (0 == connection->response->total_size)
             {
-              if (connection->response->crc != NULL)
+              if (NULL != connection->response->crc)
                 pthread_mutex_unlock (&connection->response->mutex);
               connection->state = MHD_CONNECTION_BODY_SENT;
               continue;
             }
           if (MHD_YES == try_ready_chunked_body (connection))
             {
-              if (connection->response->crc != NULL)
+              if (NULL != connection->response->crc)
                 pthread_mutex_unlock (&connection->response->mutex);
               connection->state = MHD_CONNECTION_CHUNKED_BODY_READY;
               continue;
             }
-          if (connection->response->crc != NULL)
+          if (NULL != connection->response->crc)
             pthread_mutex_unlock (&connection->response->mutex);
           break;
         case MHD_CONNECTION_BODY_SENT:
@@ -2404,7 +2395,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
           }
 #endif
           end =
-            MHD_get_response_header (connection->response, 
+            MHD_get_response_header (connection->response,
                                      MHD_HTTP_HEADER_CONNECTION);
           rend = ( (MHD_YES == connection->read_closed) ||
                    ( (end != NULL) && (0 == strcasecmp (end, "close")) ) );
@@ -2414,7 +2405,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
             daemon->notify_completed (daemon->notify_completed_cls,
                                       connection,
                                       &connection->client_context,
-                                                  MHD_REQUEST_TERMINATED_COMPLETED_OK);     
+                                                  MHD_REQUEST_TERMINATED_COMPLETED_OK);
           connection->client_aware = MHD_NO;
           end =
             MHD_lookup_connection_value (connection, MHD_HEADER_KIND,
@@ -2478,7 +2469,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
       return MHD_YES;
     }
   MHD_connection_update_event_loop_info (connection);
-#if EPOLL_SUPPORT   
+#if EPOLL_SUPPORT
   switch (connection->event_loop_info)
     {
     case MHD_EVENT_LOOP_INFO_READ:
@@ -2492,7 +2483,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
         }
       break;
     case MHD_EVENT_LOOP_INFO_WRITE:
-      if ( (connection->read_buffer_size > connection->read_buffer_offset) && 
+      if ( (connection->read_buffer_size > connection->read_buffer_offset) &&
            (0 != (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) &&
            (0 == (connection->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL)) )
         {
@@ -2517,7 +2508,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
         {
           EDLL_insert (daemon->eready_head,
                        daemon->eready_tail,
-                       connection);      
+                       connection);
           connection->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
         }
       break;
@@ -2540,13 +2531,13 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
  * @param connection connection to process
  * @return #MHD_YES if we should continue to process the
  *         connection (not dead yet), #MHD_NO if it died
- */ 
+ */
 int
 MHD_connection_epoll_update_ (struct MHD_Connection *connection)
 {
   struct MHD_Daemon *daemon = connection->daemon;
 
-  if ( (0 != (daemon->options & MHD_USE_EPOLL_LINUX_ONLY)) &&  
+  if ( (0 != (daemon->options & MHD_USE_EPOLL_LINUX_ONLY)) &&
        (0 == (connection->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET)) &&
        ( (0 == (connection->epoll_state & MHD_EPOLL_STATE_WRITE_READY)) ||
          ( (0 == (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) &&
@@ -2558,7 +2549,7 @@ MHD_connection_epoll_update_ (struct MHD_Connection *connection)
       struct epoll_event event;
 
       event.events = EPOLLIN | EPOLLOUT | EPOLLET;
-      event.data.ptr = connection;        
+      event.data.ptr = connection;
       if (0 != epoll_ctl (daemon->epoll_fd,
                           EPOLL_CTL_ADD,
                           connection->socket_fd,
@@ -2566,8 +2557,8 @@ MHD_connection_epoll_update_ (struct MHD_Connection *connection)
         {
 #if HAVE_MESSAGES
           if (0 != (daemon->options & MHD_USE_DEBUG))
-            MHD_DLOG (daemon, 
-                      "Call to epoll_ctl failed: %s\n", 
+            MHD_DLOG (daemon,
+                      "Call to epoll_ctl failed: %s\n",
                       STRERROR (errno));
 #endif
           connection->state = MHD_CONNECTION_CLOSED;
@@ -2649,7 +2640,7 @@ MHD_get_connection_info (struct MHD_Connection *connection,
  * @return #MHD_YES on success, #MHD_NO if setting the option failed
  * @ingroup specialized
  */
-int 
+int
 MHD_set_connection_option (struct MHD_Connection *connection,
                            enum MHD_CONNECTION_OPTION option,
                            ...)
@@ -2657,13 +2648,13 @@ MHD_set_connection_option (struct MHD_Connection *connection,
   va_list ap;
   struct MHD_Daemon *daemon;
 
-  daemon = connection->daemon;      
+  daemon = connection->daemon;
   switch (option)
     {
     case MHD_CONNECTION_OPTION_TIMEOUT:
       if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
            (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )
-        MHD_PANIC ("Failed to acquire cleanup mutex\n");    
+        MHD_PANIC ("Failed to acquire cleanup mutex\n");
       if (connection->connection_timeout == daemon->connection_timeout)
         XDLL_remove (daemon->normal_timeout_head,
                      daemon->normal_timeout_tail,
@@ -2685,7 +2676,7 @@ MHD_set_connection_option (struct MHD_Connection *connection,
                      connection);
       if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
            (0 != pthread_mutex_unlock (&daemon->cleanup_connection_mutex)) )
-        MHD_PANIC ("Failed to release cleanup mutex\n");    
+        MHD_PANIC ("Failed to release cleanup mutex\n");
       return MHD_YES;
     default:
       return MHD_NO;
diff --git a/src/microhttpd/daemon.c b/src/microhttpd/daemon.c
index 70741fba..61416a7b 100644
--- a/src/microhttpd/daemon.c
+++ b/src/microhttpd/daemon.c
@@ -104,7 +104,7 @@
  * @param line line number with the problem
  * @param reason error message with details
  */
-static void 
+static void
 mhd_panic_std (void *cls,
                const char *file,
                unsigned int line,
@@ -133,7 +133,7 @@ void *mhd_panic_cls;
  * Trace up to and return master daemon. If the supplied daemon
  * is a master, then return the daemon itself.
  *
- * @param daemon handle to a daemon 
+ * @param daemon handle to a daemon
  * @return master daemon handle
  */
 static struct MHD_Daemon*
@@ -162,12 +162,12 @@ struct MHD_IPCount
   {
     /**
      * IPv4 address.
-     */ 
+     */
     struct in_addr ipv4;
 #if HAVE_IPV6
     /**
      * IPv6 address.
-     */ 
+     */
     struct in6_addr ipv6;
 #endif
   } addr;
@@ -213,7 +213,7 @@ MHD_ip_count_unlock (struct MHD_Daemon *daemon)
  * Tree comparison function for IP addresses (supplied to tsearch() family).
  * We compare everything in the struct up through the beginning of the
  * 'count' field.
- * 
+ *
  * @param a1 first address to compare
  * @param a2 second address to compare
  * @return -1, 0 or 1 depending on result of compare
@@ -234,7 +234,7 @@ MHD_ip_addr_compare (const void *a1, const void *a2)
  * @return #MHD_YES on success and #MHD_NO otherwise (e.g., invalid address type)
  */
 static int
-MHD_ip_addr_to_key (const struct sockaddr *addr, 
+MHD_ip_addr_to_key (const struct sockaddr *addr,
                     socklen_t addrlen,
                     struct MHD_IPCount *key)
 {
@@ -302,14 +302,14 @@ MHD_ip_limit_add (struct MHD_Daemon *daemon,
   MHD_ip_count_lock (daemon);
 
   /* Search for the IP address */
-  if (NULL == (nodep = TSEARCH (key, 
-                                &daemon->per_ip_connection_count, 
+  if (NULL == (nodep = TSEARCH (key,
+                                &daemon->per_ip_connection_count,
                                 &MHD_ip_addr_compare)))
     {
 #if HAVE_MESSAGES
       MHD_DLOG (daemon,
                 "Failed to add IP connection count node\n");
-#endif      
+#endif
       MHD_ip_count_unlock (daemon);
       free (key);
       return MHD_NO;
@@ -358,10 +358,10 @@ MHD_ip_limit_del (struct MHD_Daemon *daemon,
   MHD_ip_count_lock (daemon);
 
   /* Search for the IP address */
-  if (NULL == (nodep = TFIND (&search_key, 
-                              &daemon->per_ip_connection_count, 
+  if (NULL == (nodep = TFIND (&search_key,
+                              &daemon->per_ip_connection_count,
                               &MHD_ip_addr_compare)))
-    {      
+    {
       /* Something's wrong if we couldn't find an IP address
        * that was previously added */
       MHD_PANIC ("Failed to find previously-added IP address\n");
@@ -375,8 +375,8 @@ MHD_ip_limit_del (struct MHD_Daemon *daemon,
   /* Remove the node entirely if count reduces to 0 */
   if (0 == --found_key->count)
     {
-      TDELETE (found_key, 
-               &daemon->per_ip_connection_count, 
+      TDELETE (found_key,
+               &daemon->per_ip_connection_count,
                &MHD_ip_addr_compare);
       free (found_key);
     }
@@ -409,7 +409,7 @@ recv_tls_adapter (struct MHD_Connection *connection, void *other, size_t i)
        (GNUTLS_E_INTERRUPTED == res) )
     {
       errno = EINTR;
-#if EPOLL_SUPPORT   
+#if EPOLL_SUPPORT
       connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY;
 #endif
       return -1;
@@ -451,7 +451,7 @@ send_tls_adapter (struct MHD_Connection *connection,
     {
       fprintf (stderr, "WAGAIN!\n");
       errno = EINTR;
-#if EPOLL_SUPPORT   
+#if EPOLL_SUPPORT
       connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
 #endif
       return -1;
@@ -472,12 +472,12 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
   gnutls_datum_t key;
   gnutls_datum_t cert;
 
-  if (NULL != daemon->https_mem_trust) 
+  if (NULL != daemon->https_mem_trust)
     {
       cert.data = (unsigned char *) daemon->https_mem_trust;
       cert.size = strlen (daemon->https_mem_trust);
       if (gnutls_certificate_set_x509_trust_mem (daemon->x509_cred, &cert,
-                                                 GNUTLS_X509_FMT_PEM) < 0) 
+                                                 GNUTLS_X509_FMT_PEM) < 0)
         {
 #if HAVE_MESSAGES
           MHD_DLOG(daemon,
@@ -486,9 +486,9 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
           return -1;
         }
     }
-  
+
   /* certificate & key loaded from memory */
-  if ( (NULL != daemon->https_mem_cert) && 
+  if ( (NULL != daemon->https_mem_cert) &&
        (NULL != daemon->https_mem_key) )
     {
       key.data = (unsigned char *) daemon->https_mem_key;
@@ -544,8 +544,8 @@ MHD_TLS_init (struct MHD_Daemon *daemon)
  * @param max_fd maximum value to potentially update
  */
 static void
-add_to_fd_set (int fd, 
-               fd_set *set, 
+add_to_fd_set (int fd,
+               fd_set *set,
                int *max_fd)
 {
   FD_SET (fd, set);
@@ -572,17 +572,17 @@ add_to_fd_set (int fd,
 int
 MHD_get_fdset (struct MHD_Daemon *daemon,
                fd_set *read_fd_set,
-               fd_set *write_fd_set, 
+               fd_set *write_fd_set,
                fd_set *except_fd_set,
                int *max_fd)
 {
   struct MHD_Connection *pos;
   int fd;
 
-  if ( (NULL == daemon) 
-       || (NULL == read_fd_set) 
+  if ( (NULL == daemon)
+       || (NULL == read_fd_set)
        || (NULL == write_fd_set)
-       || (NULL == except_fd_set) 
+       || (NULL == except_fd_set)
        || (NULL == max_fd)
        || (MHD_YES == daemon->shutdown)
        || (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
@@ -597,7 +597,7 @@ MHD_get_fdset (struct MHD_Daemon *daemon,
       if (daemon->epoll_fd >= FD_SETSIZE)
         return MHD_NO; /* poll fd too big, fail hard */
       FD_SET (daemon->epoll_fd, read_fd_set);
-      if ((*max_fd) < daemon->epoll_fd) 
+      if ((*max_fd) < daemon->epoll_fd)
         *max_fd = daemon->epoll_fd;
       return MHD_YES;
     }
@@ -607,7 +607,7 @@ MHD_get_fdset (struct MHD_Daemon *daemon,
   {
     FD_SET (fd, read_fd_set);
     /* update max file descriptor */
-    if ((*max_fd) < fd) 
+    if ((*max_fd) < fd)
       *max_fd = fd;
   }
   for (pos = daemon->connections_head; NULL != pos; pos = pos->next)
@@ -643,7 +643,7 @@ MHD_get_fdset (struct MHD_Daemon *daemon,
 /**
  * Main function of the thread that handles an individual
  * connection when #MHD_USE_THREAD_PER_CONNECTION is set.
- * 
+ *
  * @param data the 'struct MHD_Connection' this thread will handle
  * @return always NULL
  */
@@ -664,8 +664,8 @@ MHD_handle_connection (void *data)
 #endif
 
   timeout = con->daemon->connection_timeout;
-  while ( (MHD_YES != con->daemon->shutdown) && 
-          (MHD_CONNECTION_CLOSED != con->state) ) 
+  while ( (MHD_YES != con->daemon->shutdown) &&
+          (MHD_CONNECTION_CLOSED != con->state) )
     {
       tvp = NULL;
       if (timeout > 0)
@@ -715,13 +715,13 @@ MHD_handle_connection (void *data)
               goto exit;
             }
           num_ready = SELECT (max + 1, &rs, &ws, NULL, tvp);
-          if (num_ready < 0) 
+          if (num_ready < 0)
             {
               if (EINTR == errno)
                 continue;
 #if HAVE_MESSAGES
               MHD_DLOG (con->daemon,
-                        "Error during select (%d): `%s'\n", 
+                        "Error during select (%d): `%s'\n",
                         max,
                         STRERROR (errno));
 #endif
@@ -730,7 +730,7 @@ MHD_handle_connection (void *data)
           /* call appropriate connection handler if necessary */
           if ( (FD_ISSET (con->socket_fd, &rs))
 #if HTTPS_SUPPORT
-               || (MHD_YES == con->tls_read_ready) 
+               || (MHD_YES == con->tls_read_ready)
 #endif
                )
             con->read_handler (con);
@@ -748,16 +748,16 @@ MHD_handle_connection (void *data)
           switch (con->event_loop_info)
             {
             case MHD_EVENT_LOOP_INFO_READ:
-              p[0].events |= POLLIN;  
+              p[0].events |= POLLIN;
               break;
             case MHD_EVENT_LOOP_INFO_WRITE:
               p[0].events |= POLLOUT;
               if (con->read_buffer_size > con->read_buffer_offset)
-                p[0].events |= POLLIN;  
+                p[0].events |= POLLIN;
               break;
             case MHD_EVENT_LOOP_INFO_BLOCK:
               if (con->read_buffer_size > con->read_buffer_offset)
-                p[0].events |= POLLIN;  
+                p[0].events |= POLLIN;
               tv.tv_sec = 0;
               tv.tv_usec = 0;
               tvp = &tv;
@@ -766,27 +766,27 @@ MHD_handle_connection (void *data)
               /* how did we get here!? */
               goto exit;
             }
-          if (poll (p, 1, 
+          if (poll (p, 1,
                     (NULL == tvp) ? -1 : tv.tv_sec * 1000) < 0)
             {
               if (EINTR == errno)
                 continue;
 #if HAVE_MESSAGES
-              MHD_DLOG (con->daemon, "Error during poll: `%s'\n", 
+              MHD_DLOG (con->daemon, "Error during poll: `%s'\n",
                         STRERROR (errno));
 #endif
               break;
             }
-          if ( (0 != (p[0].revents & POLLIN)) 
+          if ( (0 != (p[0].revents & POLLIN))
 #if HTTPS_SUPPORT
-               || (MHD_YES == con->tls_read_ready) 
+               || (MHD_YES == con->tls_read_ready)
 #endif
                )
-            con->read_handler (con);        
-          if (0 != (p[0].revents & POLLOUT)) 
-            con->write_handler (con);        
-          if (0 != (p[0].revents & (POLLERR | POLLHUP))) 
-            MHD_connection_close (con, MHD_REQUEST_TERMINATED_WITH_ERROR);      
+            con->read_handler (con);
+          if (0 != (p[0].revents & POLLOUT))
+            con->write_handler (con);
+          if (0 != (p[0].revents & (POLLERR | POLLHUP)))
+            MHD_connection_close (con, MHD_REQUEST_TERMINATED_WITH_ERROR);
           if (MHD_NO == con->idle_handler (con))
             goto exit;
         }
@@ -801,7 +801,7 @@ MHD_handle_connection (void *data)
 #endif
 #endif
       if (MHD_CONNECTION_CLOSED != con->state)
-        MHD_connection_close (con, 
+        MHD_connection_close (con,
                               MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN);
       con->idle_handler (con);
     }
@@ -825,7 +825,7 @@ exit:
  */
 static ssize_t
 recv_param_adapter (struct MHD_Connection *connection,
-                    void *other, 
+                    void *other,
                     size_t i)
 {
   ssize_t ret;
@@ -887,7 +887,7 @@ send_param_adapter (struct MHD_Connection *connection,
       left = connection->response->total_size - connection->response_write_position;
       if (left > SSIZE_MAX)
         left = SSIZE_MAX; /* cap at return value limit */
-      if (-1 != (ret = sendfile (connection->socket_fd, 
+      if (-1 != (ret = sendfile (connection->socket_fd,
                                  fd,
                                  &offset,
                                  (size_t) left)))
@@ -904,7 +904,7 @@ send_param_adapter (struct MHD_Connection *connection,
       if ( (EINTR == errno) || (EAGAIN == errno) )
         return 0;
       if ( (EINVAL == errno) || (EBADF == errno) )
-        return -1; 
+        return -1;
       /* None of the 'usual' sendfile errors occurred, so we should try
          to fall back to 'SEND'; see also this thread for info on
          odd libc/Linux behavior with sendfile:
@@ -934,7 +934,7 @@ typedef void *(*ThreadStartRoutine)(void *cls);
 
 /**
  * Create a thread and set the attributes according to our options.
- * 
+ *
  * @param thread handle to initialize
  * @param daemon daemon with options
  * @param start_routine main function of thread
@@ -950,10 +950,10 @@ create_thread (pthread_t *thread,
   pthread_attr_t attr;
   pthread_attr_t *pattr;
   int ret;
-  
-  if (0 != daemon->thread_stack_size) 
+
+  if (0 != daemon->thread_stack_size)
     {
-      if (0 != (ret = pthread_attr_init (&attr))) 
+      if (0 != (ret = pthread_attr_init (&attr)))
         goto ERR;
       if (0 != (ret = pthread_attr_setstacksize (&attr, daemon->thread_stack_size)))
         {
@@ -973,7 +973,7 @@ create_thread (pthread_t *thread,
   (void) pthread_setname_np (*thread, "libmicrohttpd");
 #endif
 #endif
-  if (0 != daemon->thread_stack_size) 
+  if (0 != daemon->thread_stack_size)
     pthread_attr_destroy (&attr);
   return ret;
  ERR:
@@ -987,11 +987,11 @@ create_thread (pthread_t *thread,
 
 
 /**
- * Add another client connection to the set of connections 
+ * Add another client connection to the set of connections
  * managed by MHD.  This API is usually not needed (since
  * MHD will accept inbound connections on the server socket).
  * Use this API in special cases, for example if your HTTP
- * server is behind NAT and needs to connect out to the 
+ * server is behind NAT and needs to connect out to the
  * HTTP client.
  *
  * The given client socket will be managed (and closed!) by MHD after
@@ -1012,8 +1012,8 @@ create_thread (pthread_t *thread,
  *        The socket will be closed in any case; 'errno' is
  *        set to indicate further details about the error.
  */
-static int 
-internal_add_connection (struct MHD_Daemon *daemon, 
+static int
+internal_add_connection (struct MHD_Daemon *daemon,
                          int client_socket,
                          const struct sockaddr *addr,
                          socklen_t addrlen,
@@ -1025,7 +1025,7 @@ internal_add_connection (struct MHD_Daemon *daemon,
   int eno;
 #if OSX
   static int on = 1;
-#endif  
+#endif
 
   if (NULL != daemon->worker_pool)
     {
@@ -1044,7 +1044,7 @@ internal_add_connection (struct MHD_Daemon *daemon,
 #if ENFILE
       errno = ENFILE;
 #endif
-      return MHD_NO;      
+      return MHD_NO;
     }
 
 #ifndef WINDOWS
@@ -1089,8 +1089,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
     }
 
   /* apply connection acceptance policy if present */
-  if ( (NULL != daemon->apc) && 
-       (MHD_NO == daemon->apc (daemon->apc_cls, 
+  if ( (NULL != daemon->apc) &&
+       (MHD_NO == daemon->apc (daemon->apc_cls,
                                addr, addrlen)) )
     {
 #if DEBUG_CLOSE
@@ -1110,8 +1110,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
 #if OSX
 #ifdef SOL_SOCKET
 #ifdef SO_NOSIGPIPE
-  setsockopt (client_socket, 
-              SOL_SOCKET, SO_NOSIGPIPE, 
+  setsockopt (client_socket,
+              SOL_SOCKET, SO_NOSIGPIPE,
               &on, sizeof (on));
 #endif
 #endif
@@ -1121,8 +1121,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
     {
       eno = errno;
 #if HAVE_MESSAGES
-      MHD_DLOG (daemon, 
-                "Error allocating memory: %s\n", 
+      MHD_DLOG (daemon,
+                "Error allocating memory: %s\n",
                 STRERROR (errno));
 #endif
       if (0 != CLOSE (client_socket))
@@ -1136,14 +1136,14 @@ internal_add_connection (struct MHD_Daemon *daemon,
   if (NULL == connection->pool)
     {
 #if HAVE_MESSAGES
-      MHD_DLOG (daemon, 
-                "Error allocating memory: %s\n", 
+      MHD_DLOG (daemon,
+                "Error allocating memory: %s\n",
                 STRERROR (errno));
 #endif
       if (0 != CLOSE (client_socket))
         MHD_PANIC ("close failed\n");
       MHD_ip_limit_del (daemon, addr, addrlen);
-      free (connection);      
+      free (connection);
 #if ENOMEM
       errno = ENOMEM;
 #endif
@@ -1155,8 +1155,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
     {
       eno = errno;
 #if HAVE_MESSAGES
-      MHD_DLOG (daemon, 
-                "Error allocating memory: %s\n", 
+      MHD_DLOG (daemon,
+                "Error allocating memory: %s\n",
                 STRERROR (errno));
 #endif
       if (0 != CLOSE (client_socket))
@@ -1172,7 +1172,7 @@ internal_add_connection (struct MHD_Daemon *daemon,
   connection->socket_fd = client_socket;
   connection->daemon = daemon;
   connection->last_activity = MHD_monotonic_time();
-  
+
   /* set default connection handlers  */
   MHD_set_http_callbacks_ (connection);
   connection->recv_cls = &recv_param_adapter;
@@ -1196,7 +1196,7 @@ internal_add_connection (struct MHD_Daemon *daemon,
             {
 #if HAVE_MESSAGES
               MHD_DLOG (daemon,
-                        "Failed to make socket %d non-blocking: %s\n", 
+                        "Failed to make socket %d non-blocking: %s\n",
                         connection->socket_fd,
                         STRERROR (errno));
 #endif
@@ -1206,8 +1206,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
           if (0 != ioctlsocket (connection->socket_fd, FIONBIO, &flags))
             {
 #if HAVE_MESSAGES
-              MHD_DLOG (daemon, 
-                        "Failed to make socket non-blocking: %s\n", 
+              MHD_DLOG (daemon,
+                        "Failed to make socket non-blocking: %s\n",
                         STRERROR (errno));
 #endif
             }
@@ -1258,14 +1258,14 @@ internal_add_connection (struct MHD_Daemon *daemon,
                                           (gnutls_push_func) &send_param_adapter);
 
       if (daemon->https_mem_trust)
-          gnutls_certificate_server_set_request (connection->tls_session, 
+          gnutls_certificate_server_set_request (connection->tls_session,
                                                  GNUTLS_CERT_REQUEST);
     }
 #endif
 
   if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
        (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )
-    MHD_PANIC ("Failed to acquire cleanup mutex\n");    
+    MHD_PANIC ("Failed to acquire cleanup mutex\n");
   XDLL_insert (daemon->normal_timeout_head,
                daemon->normal_timeout_tail,
                connection);
@@ -1274,7 +1274,7 @@ internal_add_connection (struct MHD_Daemon *daemon,
               connection);
   if  ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
         (0 != pthread_mutex_unlock (&daemon->cleanup_connection_mutex)) )
-    MHD_PANIC ("Failed to release cleanup mutex\n");    
+    MHD_PANIC ("Failed to release cleanup mutex\n");
 
   /* attempt to create handler thread */
   if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
@@ -1307,9 +1307,9 @@ internal_add_connection (struct MHD_Daemon *daemon,
       if (0 == (daemon->options & MHD_USE_EPOLL_TURBO))
         {
           struct epoll_event event;
-          
+
           event.events = EPOLLIN | EPOLLOUT | EPOLLET;
-          event.data.ptr = connection;    
+          event.data.ptr = connection;
           if (0 != epoll_ctl (daemon->epoll_fd,
                               EPOLL_CTL_ADD,
                               client_socket,
@@ -1317,10 +1317,9 @@ internal_add_connection (struct MHD_Daemon *daemon,
             {
               eno = errno;
 #if HAVE_MESSAGES
-              if (0 != (daemon->options & MHD_USE_DEBUG))
-                MHD_DLOG (daemon, 
-                          "Call to epoll_ctl failed: %s\n", 
-                          STRERROR (errno));
+              MHD_DLOG (daemon,
+                        "Call to epoll_ctl failed: %s\n",
+                        STRERROR (errno));
 #endif
               goto cleanup;
             }
@@ -1336,15 +1335,15 @@ internal_add_connection (struct MHD_Daemon *daemon,
         }
     }
 #endif
-  daemon->max_connections--;  
-  return MHD_YES;  
+  daemon->max_connections--;
+  return MHD_YES;
  cleanup:
   if (0 != CLOSE (client_socket))
     MHD_PANIC ("close failed\n");
   MHD_ip_limit_del (daemon, addr, addrlen);
   if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
-       (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )    
-    MHD_PANIC ("Failed to acquire cleanup mutex\n");    
+       (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )
+    MHD_PANIC ("Failed to acquire cleanup mutex\n");
   DLL_remove (daemon->connections_head,
               daemon->connections_tail,
               connection);
@@ -1354,7 +1353,7 @@ internal_add_connection (struct MHD_Daemon *daemon,
   if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
        (0 != pthread_mutex_unlock (&daemon->cleanup_connection_mutex)) )
     MHD_PANIC ("Failed to release cleanup mutex\n");
-  MHD_pool_destroy (connection->pool); 
+  MHD_pool_destroy (connection->pool);
   free (connection->addr);
   free (connection);
 #if EINVAL
@@ -1365,11 +1364,150 @@ internal_add_connection (struct MHD_Daemon *daemon,
 
 
 /**
+ * Suspend handling of network data for a given connection.  This can
+ * be used to dequeue a connection from MHD's event loop (external
+ * select, internal select or thread pool; not applicable to
+ * thread-per-connection!) for a while.
+ *
+ * If you use this API in conjunction with a internal select or a
+ * thread pool, you must set the option #MHD_USE_PIPE_FOR_SHUTDOWN to
+ * ensure that a resumed connection is immediately processed by MHD.
+ *
+ * Suspended connections continue to count against the total number of
+ * connections allowed (per daemon, as well as per IP, if such limits
+ * are set).  Suspended connections will NOT time out; timeouts will
+ * restart when the connection handling is resumed.  While a
+ * connection is suspended, MHD will not detect disconnects by the
+ * client.
+ *
+ * The only safe time to suspend a connection is from the
+ * #MHD_AccessHandlerCallback.
+ *
+ * Finally, it is an API violation to call #MHD_stop_daemon while
+ * having suspended connections (this will at least create memory and
+ * socket leaks or lead to undefined behavior).  You must explicitly
+ * resume all connections before stopping the daemon.
+ *
+ * @param connection the connection to suspend
+ */
+void
+MHD_suspend_connection (struct MHD_Connection *connection)
+{
+  struct MHD_Daemon *daemon;
+
+  daemon = connection->daemon;
+  if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
+    MHD_PANIC ("Cannot suspend connections in THREAD_PER_CONNECTION mode!\n");
+  DLL_remove (daemon->connections_head,
+              daemon->connections_tail,
+              connection);
+  if (connection->connection_timeout == daemon->connection_timeout)
+    XDLL_remove (daemon->normal_timeout_head,
+                 daemon->normal_timeout_tail,
+                 connection);
+  else
+    XDLL_remove (daemon->manual_timeout_head,
+                 daemon->manual_timeout_tail,
+                 connection);
+#if EPOLL_SUPPORT
+  if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
+    {
+      EDLL_remove (daemon->eready_head,
+                   daemon->eready_tail,
+                   connection);
+    }
+  if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET))
+    {
+      if (0 != epoll_ctl (daemon->epoll_fd,
+                          EPOLL_CTL_DEL,
+                          connection->socket_fd,
+                          NULL))
+        MHD_PANIC ("Failed to remove FD from epoll set\n");
+      connection->epoll_state &= ~MHD_EPOLL_STATE_IN_EPOLL_SET;
+    }
+#endif
+}
+
+
+/**
+ * Resume handling of network data for suspended connection.  It is
+ * safe to resume a suspended connection at any time.  Calling this function
+ * on a connection that was not previously suspended will result
+ * in undefined behavior.
+ *
+ * @param connection the connection to resume
+ */
+void
+MHD_resume_connection (struct MHD_Connection *connection)
+{
+  struct MHD_Daemon *daemon;
+
+  daemon = connection->daemon;
+  if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
+    MHD_PANIC ("Cannot resume connections in THREAD_PER_CONNECTION mode!\n");
+  if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
+       (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )
+    MHD_PANIC ("Failed to acquire cleanup mutex\n");
+  DLL_insert (daemon->connections_head,
+              daemon->connections_tail,
+              connection);
+  if (connection->connection_timeout == daemon->connection_timeout)
+    XDLL_insert (daemon->normal_timeout_head,
+                 daemon->normal_timeout_tail,
+                 connection);
+  else
+    XDLL_insert (daemon->manual_timeout_head,
+                 daemon->manual_timeout_tail,
+                 connection);
+#if EPOLL_SUPPORT
+  if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
+    {
+      EDLL_insert (daemon->eready_head,
+                   daemon->eready_tail,
+                   connection);
+    }
+  else
+    {
+      struct epoll_event event;
+
+      event.events = EPOLLIN | EPOLLOUT | EPOLLET;
+      event.data.ptr = connection;
+      if (0 != epoll_ctl (daemon->epoll_fd,
+                          EPOLL_CTL_ADD,
+                          connection->socket_fd,
+                          &event))
+        {
+#if HAVE_MESSAGES
+          MHD_DLOG (daemon,
+                    "Call to epoll_ctl failed: %s\n",
+                    STRERROR (errno));
+#endif
+          /* and now, good luck with this... */
+        }
+      else
+        connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
+    }
+#endif
+  if ( (-1 != daemon->wpipe[1]) &&
+       (1 != WRITE (daemon->wpipe[1], "n", 1)) )
+    {
+#if HAVE_MESSAGES
+      MHD_DLOG (daemon,
+                "failed to signal resume via pipe");
+#endif
+    }
+  if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
+       (0 != pthread_mutex_unlock (&daemon->cleanup_connection_mutex)) )
+    MHD_PANIC ("Failed to release cleanup mutex\n");
+}
+
+
+/**
  * Change socket options to be non-blocking, non-inheritable.
  *
  * @param daemon daemon context
  * @param sock socket to manipulate
- */ 
+ */
 static void
 make_nonblocking_noninheritable (struct MHD_Daemon *daemon,
                                  int sock)
@@ -1389,12 +1527,12 @@ make_nonblocking_noninheritable (struct MHD_Daemon *daemon,
 #ifdef WINDOWS
   DWORD dwFlags;
   unsigned long flags = 1;
-  
+
   if (0 != ioctlsocket (sock, FIONBIO, &flags))
     {
 #if HAVE_MESSAGES
-      MHD_DLOG (daemon, 
-                "Failed to make socket non-blocking: %s\n", 
+      MHD_DLOG (daemon,
+                "Failed to make socket non-blocking: %s\n",
                 STRERROR (errno));
 #endif
     }
@@ -1405,13 +1543,13 @@ make_nonblocking_noninheritable (struct MHD_Daemon *daemon,
 #if HAVE_MESSAGES
       SetErrnoFromWinError (GetLastError ());
       MHD_DLOG (daemon,
-                "Failed to make socket non-inheritable: %s\n", 
+                "Failed to make socket non-inheritable: %s\n",
                 STRERROR (errno));
 #endif
-    }    
+    }
 #else
   int flags;
-  
+
   nonblock = O_NONBLOCK;
 #ifdef CYGWIN
   if (0 == (daemon->options & MHD_USE_SSL))
@@ -1424,7 +1562,7 @@ make_nonblocking_noninheritable (struct MHD_Daemon *daemon,
     {
 #if HAVE_MESSAGES
       MHD_DLOG (daemon,
-                "Failed to make socket non-inheritable: %s\n", 
+                "Failed to make socket non-inheritable: %s\n",
                 STRERROR (errno));
 #endif
     }
@@ -1461,13 +1599,13 @@ make_nonblocking_noninheritable (struct MHD_Daemon *daemon,
  *        set to indicate further details about the error.
  * @ingroup specialized
  */
-int 
-MHD_add_connection (struct MHD_Daemon *daemon, 
+int
+MHD_add_connection (struct MHD_Daemon *daemon,
                     int client_socket,
                     const struct sockaddr *addr,
                     socklen_t addrlen)
 {
-  make_nonblocking_noninheritable (daemon, 
+  make_nonblocking_noninheritable (daemon,
                                    client_socket);
   return internal_add_connection (daemon,
                                   client_socket,
@@ -1480,7 +1618,7 @@ MHD_add_connection (struct MHD_Daemon *daemon,
  * Accept an incoming connection and create the MHD_Connection object for
  * it.  This function also enforces policy by way of checking with the
  * accept policy callback.
- * 
+ *
  * @param daemon handle with the listen socket
  * @return MHD_YES on success (connections denied by policy or due
  *         to 'out of memory' and similar errors) are still considered
@@ -1525,8 +1663,8 @@ MHD_accept_connection (struct MHD_Daemon *daemon)
 #if HAVE_MESSAGES
       /* This could be a common occurance with multiple worker threads */
       if ((EAGAIN != errno) && (EWOULDBLOCK != errno))
-        MHD_DLOG (daemon, 
-                  "Error accepting connection: %s\n", 
+        MHD_DLOG (daemon,
+                  "Error accepting connection: %s\n",
                   STRERROR (errno));
 #endif
       if (-1 != s)
@@ -1567,7 +1705,7 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
 
   if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
        (0 != pthread_mutex_lock (&daemon->cleanup_connection_mutex)) )
-    MHD_PANIC ("Failed to acquire cleanup mutex\n");    
+    MHD_PANIC ("Failed to acquire cleanup mutex\n");
   while (NULL != (pos = daemon->cleanup_head))
     {
       DLL_remove (daemon->cleanup_head,
@@ -1575,7 +1713,7 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
                   pos);
       if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
            (MHD_NO == pos->thread_joined) )
-        { 
+        {
           if (0 != (rc = pthread_join (pos->pid, &unused)))
             {
               MHD_PANIC ("Failed to join a thread\n");
@@ -1586,8 +1724,8 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
       if (pos->tls_session != NULL)
         gnutls_deinit (pos->tls_session);
 #endif
-      MHD_ip_limit_del (daemon, 
-                        (struct sockaddr *) pos->addr, 
+      MHD_ip_limit_del (daemon,
+                        (struct sockaddr *) pos->addr,
                         pos->addr_len);
 #if EPOLL_SUPPORT
       if (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
@@ -1633,9 +1771,9 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
       free (pos);
       daemon->max_connections++;
     }
-  if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) && 
-       (0 != pthread_mutex_unlock (&daemon->cleanup_connection_mutex)) )    
-    MHD_PANIC ("Failed to release cleanup mutex\n");    
+  if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
+       (0 != pthread_mutex_unlock (&daemon->cleanup_connection_mutex)) )
+    MHD_PANIC ("Failed to release cleanup mutex\n");
 }
 
 
@@ -1666,7 +1804,7 @@ MHD_get_timeout (struct MHD_Daemon *daemon,
     {
 #if HAVE_MESSAGES
       MHD_DLOG (daemon, "Illegal call to MHD_get_timeout\n");
-#endif  
+#endif
       return MHD_NO;
     }
 
@@ -1683,7 +1821,7 @@ MHD_get_timeout (struct MHD_Daemon *daemon,
   have_timeout = MHD_NO;
   for (pos = daemon->manual_timeout_head; NULL != pos; pos = pos->nextX)
     {
-      if (0 != pos->connection_timeout) 
+      if (0 != pos->connection_timeout)
         {
           if ( (! have_timeout) ||
                (earliest_deadline > pos->last_activity + pos->connection_timeout) )
@@ -1743,7 +1881,7 @@ MHD_get_timeout (struct MHD_Daemon *daemon,
  * @ingroup event
  */
 int
-MHD_run_from_select (struct MHD_Daemon *daemon, 
+MHD_run_from_select (struct MHD_Daemon *daemon,
                      const fd_set *read_fd_set,
                      const fd_set *write_fd_set,
                      const fd_set *except_fd_set)
@@ -1790,7 +1928,7 @@ MHD_run_from_select (struct MHD_Daemon *daemon,
             case MHD_EVENT_LOOP_INFO_READ:
               if ( (FD_ISSET (ds, read_fd_set))
 #if HTTPS_SUPPORT
-                   || (MHD_YES == pos->tls_read_ready) 
+                   || (MHD_YES == pos->tls_read_ready)
 #endif
                    )
                 pos->read_handler (pos);
@@ -1811,7 +1949,7 @@ MHD_run_from_select (struct MHD_Daemon *daemon,
               /* should never happen */
               break;
             }
-          pos->idle_handler (pos);      
+          pos->idle_handler (pos);
         }
     }
   MHD_cleanup_connections (daemon);
@@ -1828,7 +1966,7 @@ MHD_run_from_select (struct MHD_Daemon *daemon,
  * @return #MHD_NO on serious errors, #MHD_YES on success
  */
 static int
-MHD_select (struct MHD_Daemon *daemon, 
+MHD_select (struct MHD_Daemon *daemon,
             int may_block)
 {
   int num_ready;
@@ -1856,14 +1994,14 @@ MHD_select (struct MHD_Daemon *daemon,
 
       /* If we're at the connection limit, no need to
          accept new connections. */
-      if ( (0 == daemon->max_connections) && 
+      if ( (0 == daemon->max_connections) &&
            (-1 != daemon->socket_fd) )
         FD_CLR (daemon->socket_fd, &rs);
     }
   else
     {
       /* accept only, have one thread per connection */
-      if (-1 != daemon->socket_fd) 
+      if (-1 != daemon->socket_fd)
         {
           max = daemon->socket_fd;
           FD_SET (daemon->socket_fd, &rs);
@@ -1938,7 +2076,7 @@ MHD_poll_all (struct MHD_Daemon *daemon,
     int timeout;
     unsigned int poll_server;
     int poll_listen;
-    
+
     memset (p, 0, sizeof (p));
     poll_server = 0;
     poll_listen = -1;
@@ -1952,7 +2090,7 @@ MHD_poll_all (struct MHD_Daemon *daemon,
         poll_listen = (int) poll_server;
         poll_server++;
       }
-    if (-1 != daemon->wpipe[0]) 
+    if (-1 != daemon->wpipe[0])
       {
         p[poll_server].fd = daemon->wpipe[0];
         p[poll_server].events = POLLIN;
@@ -1966,7 +2104,7 @@ MHD_poll_all (struct MHD_Daemon *daemon,
       timeout = -1;
     else
       timeout = (ltimeout > INT_MAX) ? INT_MAX : (int) ltimeout;
-    
+
     i = 0;
     for (pos = daemon->connections_head; NULL != pos; pos = pos->next)
       {
@@ -1974,16 +2112,16 @@ MHD_poll_all (struct MHD_Daemon *daemon,
         switch (pos->event_loop_info)
           {
           case MHD_EVENT_LOOP_INFO_READ:
-            p[poll_server+i].events |= POLLIN;        
+            p[poll_server+i].events |= POLLIN;
             break;
           case MHD_EVENT_LOOP_INFO_WRITE:
             p[poll_server+i].events |= POLLOUT;
             if (pos->read_buffer_size > pos->read_buffer_offset)
-              p[poll_server+i].events |= POLLIN;        
+              p[poll_server+i].events |= POLLIN;
             break;
           case MHD_EVENT_LOOP_INFO_BLOCK:
             if (pos->read_buffer_size > pos->read_buffer_offset)
-              p[poll_server+i].events |= POLLIN;        
+              p[poll_server+i].events |= POLLIN;
             break;
           case MHD_EVENT_LOOP_INFO_CLEANUP:
             /* should never happen */
@@ -1993,20 +2131,20 @@ MHD_poll_all (struct MHD_Daemon *daemon,
       }
     if (0 == poll_server + num_connections)
       return MHD_YES;
-    if (poll (p, poll_server + num_connections, timeout) < 0) 
+    if (poll (p, poll_server + num_connections, timeout) < 0)
       {
         if (EINTR == errno)
           return MHD_YES;
 #if HAVE_MESSAGES
-        MHD_DLOG (daemon, 
-                  "poll failed: %s\n", 
+        MHD_DLOG (daemon,
+                  "poll failed: %s\n",
                   STRERROR (errno));
 #endif
         return MHD_NO;
       }
     /* handle shutdown */
     if (MHD_YES == daemon->shutdown)
-      return MHD_NO;  
+      return MHD_NO;
     i = 0;
     next = daemon->connections_head;
     while (NULL != (pos = next))
@@ -2017,11 +2155,11 @@ MHD_poll_all (struct MHD_Daemon *daemon,
           case MHD_EVENT_LOOP_INFO_READ:
             /* first, sanity checks */
             if (i >= num_connections)
-              break; /* connection list changed somehow, retry later ... */     
+              break; /* connection list changed somehow, retry later ... */
             if (p[poll_server+i].fd != pos->socket_fd)
               break; /* fd mismatch, something else happened, retry later ... */
             /* normal handling */
-            if (0 != (p[poll_server+i].revents & POLLIN)) 
+            if (0 != (p[poll_server+i].revents & POLLIN))
               pos->read_handler (pos);
             pos->idle_handler (pos);
             i++;
@@ -2029,19 +2167,19 @@ MHD_poll_all (struct MHD_Daemon *daemon,
           case MHD_EVENT_LOOP_INFO_WRITE:
             /* first, sanity checks */
             if (i >= num_connections)
-              break; /* connection list changed somehow, retry later ... */     
+              break; /* connection list changed somehow, retry later ... */
             if (p[poll_server+i].fd != pos->socket_fd)
               break; /* fd mismatch, something else happened, retry later ... */
             /* normal handling */
-            if (0 != (p[poll_server+i].revents & POLLIN)) 
+            if (0 != (p[poll_server+i].revents & POLLIN))
               pos->read_handler (pos);
-            if (0 != (p[poll_server+i].revents & POLLOUT)) 
+            if (0 != (p[poll_server+i].revents & POLLOUT))
               pos->write_handler (pos);
             pos->idle_handler (pos);
             i++;
             break;
           case MHD_EVENT_LOOP_INFO_BLOCK:
-            if (0 != (p[poll_server+i].revents & POLLIN)) 
+            if (0 != (p[poll_server+i].revents & POLLIN))
               pos->read_handler (pos);
             pos->idle_handler (pos);
             break;
@@ -2074,7 +2212,7 @@ MHD_poll_listen_socket (struct MHD_Daemon *daemon,
   int timeout;
   unsigned int poll_count;
   int poll_listen;
-    
+
   memset (&p, 0, sizeof (p));
   poll_count = 0;
   poll_listen = -1;
@@ -2110,10 +2248,10 @@ MHD_poll_listen_socket (struct MHD_Daemon *daemon,
     }
   /* handle shutdown */
   if (MHD_YES == daemon->shutdown)
-    return MHD_NO;  
+    return MHD_NO;
   if ( (-1 != poll_listen) &&
        (0 != (p[poll_listen].revents & POLLIN)) )
-    (void) MHD_accept_connection (daemon);  
+    (void) MHD_accept_connection (daemon);
   return MHD_YES;
 }
 #endif
@@ -2175,7 +2313,7 @@ MHD_epoll (struct MHD_Daemon *daemon,
   int timeout_ms;
   MHD_UNSIGNED_LONG_LONG timeout_ll;
   int num_events;
-  unsigned int i;  
+  unsigned int i;
   unsigned int series_length;
 
   if (-1 == daemon->epoll_fd)
@@ -2187,7 +2325,7 @@ MHD_epoll (struct MHD_Daemon *daemon,
        (MHD_NO == daemon->listen_socket_in_epoll) )
     {
       event.events = EPOLLIN;
-      event.data.ptr = daemon;    
+      event.data.ptr = daemon;
       if (0 != epoll_ctl (daemon->epoll_fd,
                           EPOLL_CTL_ADD,
                           daemon->socket_fd,
@@ -2195,8 +2333,8 @@ MHD_epoll (struct MHD_Daemon *daemon,
         {
 #if HAVE_MESSAGES
           if (0 != (daemon->options & MHD_USE_DEBUG))
-            MHD_DLOG (daemon, 
-                      "Call to epoll_ctl failed: %s\n", 
+            MHD_DLOG (daemon,
+                      "Call to epoll_ctl failed: %s\n",
                       STRERROR (errno));
 #endif
           return MHD_NO;
@@ -2247,8 +2385,8 @@ MHD_epoll (struct MHD_Daemon *daemon,
             return MHD_YES;
 #if HAVE_MESSAGES
           if (0 != (daemon->options & MHD_USE_DEBUG))
-            MHD_DLOG (daemon, 
-                      "Call to epoll_wait failed: %s\n", 
+            MHD_DLOG (daemon,
+                      "Call to epoll_wait failed: %s\n",
                       STRERROR (errno));
 #endif
           return MHD_NO;
@@ -2270,7 +2408,7 @@ MHD_epoll (struct MHD_Daemon *daemon,
                          (pos->read_buffer_size > pos->read_buffer_offset) ) &&
                        (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
                     {
-                      EDLL_insert (daemon->eready_head, 
+                      EDLL_insert (daemon->eready_head,
                                    daemon->eready_tail,
                                    pos);
                       pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
@@ -2282,7 +2420,7 @@ MHD_epoll (struct MHD_Daemon *daemon,
                   if ( (MHD_EVENT_LOOP_INFO_WRITE == pos->event_loop_info) &&
                        (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
                     {
-                      EDLL_insert (daemon->eready_head, 
+                      EDLL_insert (daemon->eready_head,
                                    daemon->eready_tail,
                                    pos);
                       pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
@@ -2368,25 +2506,25 @@ MHD_epoll (struct MHD_Daemon *daemon,
 int
 MHD_run (struct MHD_Daemon *daemon)
 {
-  if ( (MHD_YES == daemon->shutdown) || 
+  if ( (MHD_YES == daemon->shutdown) ||
        (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) ||
        (0 != (daemon->options & MHD_USE_SELECT_INTERNALLY)) )
     return MHD_NO;
-  if (0 != (daemon->options & MHD_USE_POLL)) 
+  if (0 != (daemon->options & MHD_USE_POLL))
   {
-    MHD_poll (daemon, MHD_NO);    
+    MHD_poll (daemon, MHD_NO);
     MHD_cleanup_connections (daemon);
   }
-#if EPOLL_SUPPORT     
-  else if (0 != (daemon->options & MHD_USE_EPOLL_LINUX_ONLY)) 
+#if EPOLL_SUPPORT
+  else if (0 != (daemon->options & MHD_USE_EPOLL_LINUX_ONLY))
   {
     MHD_epoll (daemon, MHD_NO);
     MHD_cleanup_connections (daemon);
   }
 #endif
   else
-  { 
-    MHD_select (daemon, MHD_NO);    
+  {
+    MHD_select (daemon, MHD_NO);
     /* MHD_select does MHD_cleanup_connections already */
   }
   return MHD_YES;
@@ -2407,13 +2545,13 @@ MHD_select_thread (void *cls)
 
   while (MHD_YES != daemon->shutdown)
     {
-      if (0 != (daemon->options & MHD_USE_POLL)) 
-        MHD_poll (daemon, MHD_YES); 
-#if EPOLL_SUPPORT     
-      else if (0 != (daemon->options & MHD_USE_EPOLL_LINUX_ONLY)) 
+      if (0 != (daemon->options & MHD_USE_POLL))
+        MHD_poll (daemon, MHD_YES);
+#if EPOLL_SUPPORT
+      else if (0 != (daemon->options & MHD_USE_EPOLL_LINUX_ONLY))
         MHD_epoll (daemon, MHD_YES);
 #endif
-      else 
+      else
         MHD_select (daemon, MHD_YES);
       MHD_cleanup_connections (daemon);
     }
@@ -2469,7 +2607,7 @@ MHD_start_daemon (unsigned int flags,
  * #MHD_start_daemon, this function will return -1.
  *
  * @param daemon daemon to stop accepting new connections for
- * @return old listen socket on success, -1 if the daemon was 
+ * @return old listen socket on success, -1 if the daemon was
  *         already not listening anymore
  * @ingroup specialized
  */
@@ -2486,7 +2624,7 @@ MHD_quiesce_daemon (struct MHD_Daemon *daemon)
        (0 != (daemon->options & MHD_USE_SELECT_INTERNALLY)) )
     {
 #if HAVE_MESSAGES
-      MHD_DLOG (daemon, 
+      MHD_DLOG (daemon,
                 "Using MHD_quiesce_daemon in this mode requires MHD_USE_PIPE_FOR_SHUTDOWN\n");
 #endif
       return -1;
@@ -2536,13 +2674,13 @@ MHD_quiesce_daemon (struct MHD_Daemon *daemon)
  * @param va arguments to the format string (fprintf-style)
  */
 typedef void (*VfprintfFunctionPointerType)(void *cls,
-                                            const char *format, 
+                                            const char *format,
                                             va_list va);
 
 
 /**
  * Parse a list of options given as varargs.
- * 
+ *
  * @param daemon the daemon to initialize
  * @param servaddr where to store the server's listen address
  * @param ap the options
@@ -2556,7 +2694,7 @@ parse_options_va (struct MHD_Daemon *daemon,
 
 /**
  * Parse a list of options given as varargs.
- * 
+ *
  * @param daemon the daemon to initialize
  * @param servaddr where to store the server's listen address
  * @param ... the options
@@ -2579,7 +2717,7 @@ parse_options (struct MHD_Daemon *daemon,
 
 /**
  * Parse a list of options given as varargs.
- * 
+ *
  * @param daemon the daemon to initialize
  * @param servaddr where to store the server's listen address
  * @param ap the options
@@ -2597,7 +2735,7 @@ parse_options_va (struct MHD_Daemon *daemon,
   int ret;
   const char *pstr;
 #endif
-  
+
   while (MHD_OPTION_END != (opt = (enum MHD_OPTION) va_arg (ap, int)))
     {
       switch (opt)
@@ -2650,7 +2788,7 @@ parse_options_va (struct MHD_Daemon *daemon,
           else
             MHD_DLOG (daemon,
                       "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not set\n",
-                      opt);       
+                      opt);
 #endif
           break;
         case MHD_OPTION_HTTPS_MEM_CERT:
@@ -2660,7 +2798,7 @@ parse_options_va (struct MHD_Daemon *daemon,
           else
             MHD_DLOG (daemon,
                       "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not set\n",
-                      opt);       
+                      opt);
 #endif
           break;
         case MHD_OPTION_HTTPS_MEM_TRUST:
@@ -2690,7 +2828,7 @@ parse_options_va (struct MHD_Daemon *daemon,
                           "Setting priorities to `%s' failed: %s\n",
                           pstr,
                           gnutls_strerror (ret));
-#endif    
+#endif
                 daemon->priority_cache = NULL;
                 return MHD_NO;
               }
@@ -2707,7 +2845,7 @@ parse_options_va (struct MHD_Daemon *daemon,
           break;
 #endif
         case MHD_OPTION_LISTEN_SOCKET:
-          daemon->socket_fd = va_arg (ap, int);   
+          daemon->socket_fd = va_arg (ap, int);
           break;
         case MHD_OPTION_EXTERNAL_LOGGER:
 #if HAVE_MESSAGES
@@ -2829,7 +2967,7 @@ parse_options_va (struct MHD_Daemon *daemon,
 #endif
           return MHD_NO;
         }
-    }  
+    }
   return MHD_YES;
 }
 
@@ -2848,7 +2986,7 @@ create_socket (struct MHD_Daemon *daemon,
 {
   int ctype = type | SOCK_CLOEXEC;
   int fd;
- 
+
   /* use SOCK_STREAM rather than ai_socktype: some getaddrinfo
    * implementations do not set ai_socktype, e.g. RHL6.2. */
   fd = SOCKET (domain, ctype, protocol);
@@ -2883,19 +3021,19 @@ setup_epoll_to_listen (struct MHD_Daemon *daemon)
     {
 #if HAVE_MESSAGES
       if (0 != (daemon->options & MHD_USE_DEBUG))
-        MHD_DLOG (daemon, 
-                  "Call to epoll_create1 failed: %s\n", 
+        MHD_DLOG (daemon,
+                  "Call to epoll_create1 failed: %s\n",
                   STRERROR (errno));
 #endif
       return MHD_NO;
     }
   if (0 == EPOLL_CLOEXEC)
-    make_nonblocking_noninheritable (daemon, 
+    make_nonblocking_noninheritable (daemon,
                                      daemon->epoll_fd);
   if (-1 == daemon->socket_fd)
     return MHD_YES; /* non-listening daemon */
   event.events = EPOLLIN;
-  event.data.ptr = daemon;        
+  event.data.ptr = daemon;
   if (0 != epoll_ctl (daemon->epoll_fd,
                       EPOLL_CTL_ADD,
                       daemon->socket_fd,
@@ -2903,8 +3041,8 @@ setup_epoll_to_listen (struct MHD_Daemon *daemon)
     {
 #if HAVE_MESSAGES
       if (0 != (daemon->options & MHD_USE_DEBUG))
-        MHD_DLOG (daemon, 
-                  "Call to epoll_ctl failed: %s\n", 
+        MHD_DLOG (daemon,
+                  "Call to epoll_ctl failed: %s\n",
                   STRERROR (errno));
 #endif
       return MHD_NO;
@@ -2955,15 +3093,15 @@ MHD_start_daemon_va (unsigned int flags,
 
 #ifndef HAVE_INET6
   if (0 != (flags & MHD_USE_IPv6))
-    return NULL;    
+    return NULL;
 #endif
 #ifndef HAVE_POLL_H
   if (0 != (flags & MHD_USE_POLL))
-    return NULL;    
+    return NULL;
 #endif
 #if ! HTTPS_SUPPORT
   if (0 != (flags & MHD_USE_SSL))
-    return NULL;    
+    return NULL;
 #endif
   if (NULL == dh)
     return NULL;
@@ -3021,7 +3159,7 @@ MHD_start_daemon_va (unsigned int flags,
     )
     {
 #if HAVE_MESSAGES
-      MHD_DLOG (daemon, 
+      MHD_DLOG (daemon,
                 "Failed to create control pipe: %s\n",
                 STRERROR (errno));
 #endif
@@ -3034,7 +3172,7 @@ MHD_start_daemon_va (unsigned int flags,
        (daemon->wpipe[0] >= FD_SETSIZE) )
     {
 #if HAVE_MESSAGES
-      MHD_DLOG (daemon, 
+      MHD_DLOG (daemon,
                 "file descriptor for control pipe exceeds maximum value\n");
 #endif
       if (0 != CLOSE (daemon->wpipe[0]))
@@ -3069,9 +3207,9 @@ MHD_start_daemon_va (unsigned int flags,
       return NULL;
     }
 #ifdef DAUTH_SUPPORT
-  if (daemon->nonce_nc_size > 0) 
+  if (daemon->nonce_nc_size > 0)
     {
-      if ( ( (size_t) (daemon->nonce_nc_size * sizeof (struct MHD_NonceNc))) / 
+      if ( ( (size_t) (daemon->nonce_nc_size * sizeof (struct MHD_NonceNc))) /
            sizeof(struct MHD_NonceNc) != daemon->nonce_nc_size)
         {
 #if HAVE_MESSAGES
@@ -3083,7 +3221,7 @@ MHD_start_daemon_va (unsigned int flags,
             gnutls_priority_deinit (daemon->priority_cache);
 #endif
           free (daemon);
-          return NULL;    
+          return NULL;
         }
       daemon->nnc = malloc (daemon->nonce_nc_size * sizeof (struct MHD_NonceNc));
       if (NULL == daemon->nnc)
@@ -3101,7 +3239,7 @@ MHD_start_daemon_va (unsigned int flags,
           return NULL;
         }
     }
-  
+
   if (0 != pthread_mutex_init (&daemon->nnc_lock, NULL))
     {
 #if HAVE_MESSAGES
@@ -3119,7 +3257,7 @@ MHD_start_daemon_va (unsigned int flags,
 #endif
 
   /* Thread pooling currently works only with internal select thread model */
-  if ( (0 == (flags & MHD_USE_SELECT_INTERNALLY)) && 
+  if ( (0 == (flags & MHD_USE_SELECT_INTERNALLY)) &&
        (daemon->worker_pool_size > 0) )
     {
 #if HAVE_MESSAGES
@@ -3179,8 +3317,8 @@ MHD_start_daemon_va (unsigned int flags,
         {
 #if HAVE_MESSAGES
           if (0 != (flags & MHD_USE_DEBUG))
-            MHD_DLOG (daemon, 
-                      "Call to socket failed: %s\n", 
+            MHD_DLOG (daemon,
+                      "Call to socket failed: %s\n",
                       STRERROR (errno));
 #endif
           goto free_and_fail;
@@ -3188,16 +3326,16 @@ MHD_start_daemon_va (unsigned int flags,
       if ( (0 > SETSOCKOPT (socket_fd,
                             SOL_SOCKET,
                             SO_REUSEADDR,
-                            &on, sizeof (on))) && 
+                            &on, sizeo