libmicrohttpd

HTTP/1.x server C library (MHD 1.x, stable)
Log | Files | Refs | Submodules | README | LICENSE

daemon.c (333485B)


      1 /*
      2   This file is part of libmicrohttpd
      3   Copyright (C) 2007-2018 Daniel Pittman and Christian Grothoff
      4   Copyright (C) 2015-2024 Evgeny Grin (Karlson2k)
      5 
      6   This library is free software; you can redistribute it and/or
      7   modify it under the terms of the GNU Lesser General Public
      8   License as published by the Free Software Foundation; either
      9   version 2.1 of the License, or (at your option) any later version.
     10 
     11   This library is distributed in the hope that it will be useful,
     12   but WITHOUT ANY WARRANTY; without even the implied warranty of
     13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14   Lesser General Public License for more details.
     15 
     16   You should have received a copy of the GNU Lesser General Public
     17   License along with this library; if not, write to the Free Software
     18   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
     19 
     20 */
     21 
     22 /**
     23  * @file microhttpd/daemon.c
     24  * @brief  A minimal-HTTP server library
     25  * @author Daniel Pittman
     26  * @author Christian Grothoff
     27  * @author Karlson2k (Evgeny Grin)
     28  */
     29 #include "platform.h"
     30 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
     31 #include "mhd_threads.h"
     32 #endif
     33 #include "internal.h"
     34 #include "response.h"
     35 #include "connection.h"
     36 #include "memorypool.h"
     37 #include "mhd_limits.h"
     38 #include "autoinit_funcs.h"
     39 #include "mhd_mono_clock.h"
     40 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
     41 #include "mhd_locks.h"
     42 #endif
     43 #include "mhd_sockets.h"
     44 #include "mhd_itc.h"
     45 #include "mhd_compat.h"
     46 #include "mhd_send.h"
     47 #include "mhd_align.h"
     48 #include "mhd_str.h"
     49 
     50 #ifdef MHD_USE_SYS_TSEARCH
     51 #include <search.h>
     52 #else  /* ! MHD_USE_SYS_TSEARCH */
     53 #include "tsearch.h"
     54 #endif /* ! MHD_USE_SYS_TSEARCH */
     55 
     56 #ifdef HTTPS_SUPPORT
     57 #include "connection_https.h"
     58 #ifdef MHD_HTTPS_REQUIRE_GCRYPT
     59 #include <gcrypt.h>
     60 #endif /* MHD_HTTPS_REQUIRE_GCRYPT */
     61 #endif /* HTTPS_SUPPORT */
     62 
     63 #if defined(_WIN32) && ! defined(__CYGWIN__)
     64 #ifndef WIN32_LEAN_AND_MEAN
     65 #define WIN32_LEAN_AND_MEAN 1
     66 #endif /* !WIN32_LEAN_AND_MEAN */
     67 #include <windows.h>
     68 #endif
     69 
     70 #ifdef MHD_USE_POSIX_THREADS
     71 #ifdef HAVE_SIGNAL_H
     72 #include <signal.h>
     73 #endif /* HAVE_SIGNAL_H */
     74 #endif /* MHD_USE_POSIX_THREADS */
     75 
     76 /**
     77  * Default connection limit.
     78  */
     79 #ifdef MHD_POSIX_SOCKETS
     80 #define MHD_MAX_CONNECTIONS_DEFAULT (FD_SETSIZE - 3 - 1 - MHD_ITC_NUM_FDS_)
     81 #else
     82 #define MHD_MAX_CONNECTIONS_DEFAULT (FD_SETSIZE - 2)
     83 #endif
     84 
     85 /**
     86  * Default memory allowed per connection.
     87  */
     88 #define MHD_POOL_SIZE_DEFAULT (32 * 1024)
     89 
     90 
     91 /* Forward declarations. */
     92 
     93 
     94 /**
     95  * Global initialisation function.
     96  */
     97 void
     98 MHD_init (void);
     99 
    100 /**
    101  * Global deinitialisation function.
    102  */
    103 void
    104 MHD_fini (void);
    105 
    106 /**
    107  * Close all connections for the daemon.
    108  * Must only be called when MHD_Daemon::shutdown was set to true.
    109  * @remark To be called only from thread that process
    110  * daemon's select()/poll()/etc.
    111  *
    112  * @param daemon daemon to close down
    113  */
    114 static void
    115 close_all_connections (struct MHD_Daemon *daemon);
    116 
    117 #ifdef EPOLL_SUPPORT
    118 
    119 /**
    120  * Do epoll()-based processing.
    121  *
    122  * @param daemon daemon to run poll loop for
    123  * @param millisec the maximum time in milliseconds to wait for events,
    124  *                 set to '0' for non-blocking processing,
    125  *                 set to '-1' to wait indefinitely.
    126  * @return #MHD_NO on serious errors, #MHD_YES on success
    127  */
    128 static enum MHD_Result
    129 MHD_epoll (struct MHD_Daemon *daemon,
    130            int32_t millisec);
    131 
    132 #endif /* EPOLL_SUPPORT */
    133 
    134 #ifdef _AUTOINIT_FUNCS_ARE_SUPPORTED
    135 /**
    136  * Do nothing - global initialisation is
    137  * performed by library constructor.
    138  */
    139 #define MHD_check_global_init_() (void) 0
    140 #else  /* ! _AUTOINIT_FUNCS_ARE_SUPPORTED */
    141 /**
    142  * Track global initialisation
    143  */
    144 volatile int global_init_count = 0;
    145 
    146 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
    147 #ifdef MHD_MUTEX_STATIC_DEFN_INIT_
    148 /**
    149  * Global initialisation mutex
    150  */
    151 MHD_MUTEX_STATIC_DEFN_INIT_ (global_init_mutex_);
    152 #endif /* MHD_MUTEX_STATIC_DEFN_INIT_ */
    153 #endif
    154 
    155 
    156 /**
    157  * Check whether global initialisation was performed
    158  * and call initialiser if necessary.
    159  */
    160 void
    161 MHD_check_global_init_ (void)
    162 {
    163 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
    164 #ifdef MHD_MUTEX_STATIC_DEFN_INIT_
    165   MHD_mutex_lock_chk_ (&global_init_mutex_);
    166 #endif /* MHD_MUTEX_STATIC_DEFN_INIT_ */
    167 #endif
    168   if (0 == global_init_count++)
    169     MHD_init ();
    170 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
    171 #ifdef MHD_MUTEX_STATIC_DEFN_INIT_
    172   MHD_mutex_unlock_chk_ (&global_init_mutex_);
    173 #endif /* MHD_MUTEX_STATIC_DEFN_INIT_ */
    174 #endif
    175 }
    176 
    177 
    178 #endif /* ! _AUTOINIT_FUNCS_ARE_SUPPORTED */
    179 
    180 #ifdef HAVE_MESSAGES
    181 /**
    182  * Default logger function
    183  */
    184 static void
    185 MHD_default_logger_ (void *cls,
    186                      const char *fm,
    187                      va_list ap)
    188 {
    189   vfprintf ((FILE *) cls, fm, ap);
    190 #ifdef _DEBUG
    191   fflush ((FILE *) cls);
    192 #endif /* _DEBUG */
    193 }
    194 
    195 
    196 #endif /* HAVE_MESSAGES */
    197 
    198 
    199 /**
    200  * Free the memory allocated by MHD.
    201  *
    202  * If any MHD function explicitly mentions that returned pointer must be
    203  * freed by this function, then no other method must be used to free
    204  * the memory.
    205  *
    206  * @param ptr the pointer to free.
    207  * @sa #MHD_digest_auth_get_username(), #MHD_basic_auth_get_username_password3()
    208  * @sa #MHD_basic_auth_get_username_password()
    209  * @note Available since #MHD_VERSION 0x00095600
    210  * @ingroup specialized
    211  */
    212 _MHD_EXTERN void
    213 MHD_free (void *ptr)
    214 {
    215   free (ptr);
    216 }
    217 
    218 
    219 /**
    220  * Maintain connection count for single address.
    221  */
    222 struct MHD_IPCount
    223 {
    224   /**
    225    * Address family. AF_INET or AF_INET6 for now.
    226    */
    227   int family;
    228 
    229   /**
    230    * Actual address.
    231    */
    232   union
    233   {
    234     /**
    235      * IPv4 address.
    236      */
    237     struct in_addr ipv4;
    238 #ifdef HAVE_INET6
    239     /**
    240      * IPv6 address.
    241      */
    242     struct in6_addr ipv6;
    243 #endif
    244   } addr;
    245 
    246   /**
    247    * Counter.
    248    */
    249   unsigned int count;
    250 };
    251 
    252 
    253 /**
    254  * Lock shared structure for IP connection counts and connection DLLs.
    255  *
    256  * @param daemon handle to daemon where lock is
    257  */
    258 static void
    259 MHD_ip_count_lock (struct MHD_Daemon *daemon)
    260 {
    261   mhd_assert (NULL == daemon->master);
    262 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
    263   MHD_mutex_lock_chk_ (&daemon->per_ip_connection_mutex);
    264 #else
    265   (void) daemon;
    266 #endif
    267 }
    268 
    269 
    270 /**
    271  * Unlock shared structure for IP connection counts and connection DLLs.
    272  *
    273  * @param daemon handle to daemon where lock is
    274  */
    275 static void
    276 MHD_ip_count_unlock (struct MHD_Daemon *daemon)
    277 {
    278   mhd_assert (NULL == daemon->master);
    279 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
    280   MHD_mutex_unlock_chk_ (&daemon->per_ip_connection_mutex);
    281 #else
    282   (void) daemon;
    283 #endif
    284 }
    285 
    286 
    287 /**
    288  * Tree comparison function for IP addresses (supplied to tsearch() family).
    289  * We compare everything in the struct up through the beginning of the
    290  * 'count' field.
    291  *
    292  * @param a1 first address to compare
    293  * @param a2 second address to compare
    294  * @return -1, 0 or 1 depending on result of compare
    295  */
    296 static int
    297 MHD_ip_addr_compare (const void *a1,
    298                      const void *a2)
    299 {
    300   return memcmp (a1,
    301                  a2,
    302                  offsetof (struct MHD_IPCount,
    303                            count));
    304 }
    305 
    306 
    307 /**
    308  * Parse address and initialize @a key using the address.
    309  *
    310  * @param addr address to parse
    311  * @param addrlen number of bytes in @a addr
    312  * @param key where to store the parsed address
    313  * @return #MHD_YES on success and #MHD_NO otherwise (e.g., invalid address type)
    314  */
    315 static enum MHD_Result
    316 MHD_ip_addr_to_key (const struct sockaddr_storage *addr,
    317                     socklen_t addrlen,
    318                     struct MHD_IPCount *key)
    319 {
    320   memset (key,
    321           0,
    322           sizeof(*key));
    323 
    324   /* IPv4 addresses */
    325   if (sizeof (struct sockaddr_in) <= (size_t) addrlen)
    326   {
    327     if (AF_INET == addr->ss_family)
    328     {
    329       key->family = AF_INET;
    330       memcpy (&key->addr.ipv4,
    331               &((const struct sockaddr_in *) addr)->sin_addr,
    332               sizeof(((const struct sockaddr_in *) NULL)->sin_addr));
    333       return MHD_YES;
    334     }
    335   }
    336 
    337 #ifdef HAVE_INET6
    338   if (sizeof (struct sockaddr_in6) <= (size_t) addrlen)
    339   {
    340     /* IPv6 addresses */
    341     if (AF_INET6 == addr->ss_family)
    342     {
    343       key->family = AF_INET6;
    344       memcpy (&key->addr.ipv6,
    345               &((const struct sockaddr_in6 *) addr)->sin6_addr,
    346               sizeof(((const struct sockaddr_in6 *) NULL)->sin6_addr));
    347       return MHD_YES;
    348     }
    349   }
    350 #endif
    351 
    352   /* Some other address */
    353   return MHD_NO;
    354 }
    355 
    356 
    357 /**
    358  * Check if IP address is over its limit in terms of the number
    359  * of allowed concurrent connections.  If the IP is still allowed,
    360  * increments the connection counter.
    361  *
    362  * @param daemon handle to daemon where connection counts are tracked
    363  * @param addr address to add (or increment counter)
    364  * @param addrlen number of bytes in @a addr
    365  * @return Return #MHD_YES if IP below limit, #MHD_NO if IP has surpassed limit.
    366  *   Also returns #MHD_NO if fails to allocate memory.
    367  */
    368 static enum MHD_Result
    369 MHD_ip_limit_add (struct MHD_Daemon *daemon,
    370                   const struct sockaddr_storage *addr,
    371                   socklen_t addrlen)
    372 {
    373   struct MHD_IPCount *newkeyp;
    374   struct MHD_IPCount *keyp;
    375   struct MHD_IPCount **nodep;
    376   enum MHD_Result result;
    377 
    378   daemon = MHD_get_master (daemon);
    379   /* Ignore if no connection limit assigned */
    380   if (0 == daemon->per_ip_connection_limit)
    381     return MHD_YES;
    382 
    383   newkeyp = (struct MHD_IPCount *) malloc (sizeof(struct MHD_IPCount));
    384   if (NULL == newkeyp)
    385     return MHD_NO;
    386 
    387   /* Initialize key */
    388   if (MHD_NO == MHD_ip_addr_to_key (addr,
    389                                     addrlen,
    390                                     newkeyp))
    391   {
    392     free (newkeyp);
    393     return MHD_YES; /* Allow unhandled address types through */
    394   }
    395 
    396   MHD_ip_count_lock (daemon);
    397 
    398   /* Search for the IP address */
    399   nodep = (struct MHD_IPCount **) tsearch (newkeyp,
    400                                            &daemon->per_ip_connection_count,
    401                                            &MHD_ip_addr_compare);
    402   if (NULL == nodep)
    403   {
    404     MHD_ip_count_unlock (daemon);
    405     free (newkeyp);
    406 #ifdef HAVE_MESSAGES
    407     MHD_DLOG (daemon,
    408               _ ("Failed to add IP connection count node.\n"));
    409 #endif
    410     return MHD_NO;
    411   }
    412   keyp = *nodep;
    413   /* Test if there is room for another connection; if so,
    414    * increment count */
    415   result = (keyp->count < daemon->per_ip_connection_limit) ? MHD_YES : MHD_NO;
    416   if (MHD_NO != result)
    417     ++keyp->count;
    418   MHD_ip_count_unlock (daemon);
    419 
    420   /* If we got an existing node back, free the one we created */
    421   if (keyp != newkeyp)
    422     free (newkeyp);
    423 
    424   return result;
    425 }
    426 
    427 
    428 /**
    429  * Decrement connection count for IP address, removing from table
    430  * count reaches 0.
    431  *
    432  * @param daemon handle to daemon where connection counts are tracked
    433  * @param addr address to remove (or decrement counter)
    434  * @param addrlen number of bytes in @a addr
    435  */
    436 static void
    437 MHD_ip_limit_del (struct MHD_Daemon *daemon,
    438                   const struct sockaddr_storage *addr,
    439                   socklen_t addrlen)
    440 {
    441   struct MHD_IPCount search_key;
    442   struct MHD_IPCount *found_key;
    443   void **nodep;
    444 
    445   daemon = MHD_get_master (daemon);
    446   /* Ignore if no connection limit assigned */
    447   if (0 == daemon->per_ip_connection_limit)
    448     return;
    449   /* Initialize search key */
    450   if (MHD_NO == MHD_ip_addr_to_key (addr,
    451                                     addrlen,
    452                                     &search_key))
    453     return;
    454 
    455   MHD_ip_count_lock (daemon);
    456 
    457   /* Search for the IP address */
    458   if (NULL == (nodep = tfind (&search_key,
    459                               &daemon->per_ip_connection_count,
    460                               &MHD_ip_addr_compare)))
    461   {
    462     /* Something's wrong if we couldn't find an IP address
    463      * that was previously added */
    464     MHD_PANIC (_ ("Failed to find previously-added IP address.\n"));
    465   }
    466   found_key = (struct MHD_IPCount *) *nodep;
    467   /* Validate existing count for IP address */
    468   if (0 == found_key->count)
    469   {
    470     MHD_PANIC (_ ("Previously-added IP address had counter of zero.\n"));
    471   }
    472   /* Remove the node entirely if count reduces to 0 */
    473   if (0 == --found_key->count)
    474   {
    475     tdelete (found_key,
    476              &daemon->per_ip_connection_count,
    477              &MHD_ip_addr_compare);
    478     MHD_ip_count_unlock (daemon);
    479     free (found_key);
    480   }
    481   else
    482     MHD_ip_count_unlock (daemon);
    483 }
    484 
    485 
    486 #ifdef HTTPS_SUPPORT
    487 /**
    488  * Read and setup our certificate and key.
    489  *
    490  * @param daemon handle to daemon to initialize
    491  * @return 0 on success
    492  */
    493 static int
    494 MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
    495 {
    496   gnutls_datum_t key;
    497   gnutls_datum_t cert;
    498   int ret;
    499 
    500 #if GNUTLS_VERSION_MAJOR >= 3
    501   if (NULL != daemon->cert_callback)
    502   {
    503     gnutls_certificate_set_retrieve_function2 (daemon->x509_cred,
    504                                                daemon->cert_callback);
    505   }
    506 #endif
    507 #if GNUTLS_VERSION_NUMBER >= 0x030603
    508   else if (NULL != daemon->cert_callback2)
    509   {
    510     gnutls_certificate_set_retrieve_function3 (daemon->x509_cred,
    511                                                daemon->cert_callback2);
    512   }
    513 #endif
    514 
    515   if (NULL != daemon->https_mem_trust)
    516   {
    517     size_t paramlen;
    518     paramlen = strlen (daemon->https_mem_trust);
    519     if (UINT_MAX < paramlen)
    520     {
    521 #ifdef HAVE_MESSAGES
    522       MHD_DLOG (daemon,
    523                 _ ("Too long trust certificate.\n"));
    524 #endif
    525       return -1;
    526     }
    527     cert.data = (unsigned char *) _MHD_DROP_CONST (daemon->https_mem_trust);
    528     cert.size = (unsigned int) paramlen;
    529     if (gnutls_certificate_set_x509_trust_mem (daemon->x509_cred,
    530                                                &cert,
    531                                                GNUTLS_X509_FMT_PEM) < 0)
    532     {
    533 #ifdef HAVE_MESSAGES
    534       MHD_DLOG (daemon,
    535                 _ ("Bad trust certificate format.\n"));
    536 #endif
    537       return -1;
    538     }
    539   }
    540 
    541   if (daemon->have_dhparams)
    542   {
    543     gnutls_certificate_set_dh_params (daemon->x509_cred,
    544                                       daemon->https_mem_dhparams);
    545   }
    546   /* certificate & key loaded from memory */
    547   if ( (NULL != daemon->https_mem_cert) &&
    548        (NULL != daemon->https_mem_key) )
    549   {
    550     size_t param1len;
    551     size_t param2len;
    552 
    553     param1len = strlen (daemon->https_mem_key);
    554     param2len = strlen (daemon->https_mem_cert);
    555     if ( (UINT_MAX < param1len) ||
    556          (UINT_MAX < param2len) )
    557     {
    558 #ifdef HAVE_MESSAGES
    559       MHD_DLOG (daemon,
    560                 _ ("Too long key or certificate.\n"));
    561 #endif
    562       return -1;
    563     }
    564     key.data = (unsigned char *) _MHD_DROP_CONST (daemon->https_mem_key);
    565     key.size = (unsigned int) param1len;
    566     cert.data = (unsigned char *) _MHD_DROP_CONST (daemon->https_mem_cert);
    567     cert.size = (unsigned int) param2len;
    568 
    569     if (NULL != daemon->https_key_password)
    570     {
    571 #if GNUTLS_VERSION_NUMBER >= 0x030111
    572       ret = gnutls_certificate_set_x509_key_mem2 (daemon->x509_cred,
    573                                                   &cert,
    574                                                   &key,
    575                                                   GNUTLS_X509_FMT_PEM,
    576                                                   daemon->https_key_password,
    577                                                   0);
    578 #else
    579 #ifdef HAVE_MESSAGES
    580       MHD_DLOG (daemon,
    581                 _ ("Failed to setup x509 certificate/key: pre 3.X.X version " \
    582                    "of GnuTLS does not support setting key password.\n"));
    583 #endif
    584       return -1;
    585 #endif
    586     }
    587     else
    588       ret = gnutls_certificate_set_x509_key_mem (daemon->x509_cred,
    589                                                  &cert,
    590                                                  &key,
    591                                                  GNUTLS_X509_FMT_PEM);
    592 #ifdef HAVE_MESSAGES
    593     if (0 != ret)
    594       MHD_DLOG (daemon,
    595                 _ ("GnuTLS failed to setup x509 certificate/key: %s\n"),
    596                 gnutls_strerror (ret));
    597 #endif
    598     return ret;
    599   }
    600 #if GNUTLS_VERSION_MAJOR >= 3
    601   if (NULL != daemon->cert_callback)
    602     return 0;
    603 #endif
    604 #if GNUTLS_VERSION_NUMBER >= 0x030603
    605   else if (NULL != daemon->cert_callback2)
    606     return 0;
    607 #endif
    608 #ifdef HAVE_MESSAGES
    609   MHD_DLOG (daemon,
    610             _ ("You need to specify a certificate and key location.\n"));
    611 #endif
    612   return -1;
    613 }
    614 
    615 
    616 /**
    617  * Initialize security aspects of the HTTPS daemon
    618  *
    619  * @param daemon handle to daemon to initialize
    620  * @return 0 on success
    621  */
    622 static int
    623 MHD_TLS_init (struct MHD_Daemon *daemon)
    624 {
    625   switch (daemon->cred_type)
    626   {
    627   case GNUTLS_CRD_CERTIFICATE:
    628     if (0 !=
    629         gnutls_certificate_allocate_credentials (&daemon->x509_cred))
    630       return GNUTLS_E_MEMORY_ERROR;
    631     return MHD_init_daemon_certificate (daemon);
    632   case GNUTLS_CRD_PSK:
    633     if (0 !=
    634         gnutls_psk_allocate_server_credentials (&daemon->psk_cred))
    635       return GNUTLS_E_MEMORY_ERROR;
    636     return 0;
    637   case GNUTLS_CRD_ANON:
    638   case GNUTLS_CRD_SRP:
    639   case GNUTLS_CRD_IA:
    640   default:
    641 #ifdef HAVE_MESSAGES
    642     MHD_DLOG (daemon,
    643               _ ("Error: invalid credentials type %d specified.\n"),
    644               daemon->cred_type);
    645 #endif
    646     return -1;
    647   }
    648 }
    649 
    650 
    651 /**
    652  * Release the TLS resources that #MHD_start_daemon_va() may already have
    653  * allocated when it decides to fail.
    654  *
    655  * The daemon object is not usable at that point, so #MHD_stop_daemon()
    656  * (which is what frees these on the success path) cannot be called; each
    657  * failure exit therefore has to do it, and every one of them used to
    658  * forget the Diffie-Hellman parameters.  Those are created by MHD itself
    659  * from the PEM blob of #MHD_OPTION_HTTPS_MEM_DHPARAMS, so the
    660  * application has no handle to free either.
    661  *
    662  * @param[in,out] daemon the half-initialised daemon
    663  */
    664 static void
    665 tls_cleanup_failed_start (struct MHD_Daemon *daemon)
    666 {
    667   if (daemon->have_dhparams)
    668   {
    669     gnutls_dh_params_deinit (daemon->https_mem_dhparams);
    670     daemon->have_dhparams = false;
    671   }
    672   if (NULL != daemon->priority_cache)
    673   {
    674     gnutls_priority_deinit (daemon->priority_cache);
    675     daemon->priority_cache = NULL;
    676   }
    677   if (NULL != daemon->x509_cred)
    678   {
    679     gnutls_certificate_free_credentials (daemon->x509_cred);
    680     daemon->x509_cred = NULL;
    681   }
    682   if (NULL != daemon->psk_cred)
    683   {
    684     gnutls_psk_free_server_credentials (daemon->psk_cred);
    685     daemon->psk_cred = NULL;
    686   }
    687 }
    688 
    689 
    690 #endif /* HTTPS_SUPPORT */
    691 
    692 
    693 #undef MHD_get_fdset
    694 
    695 /**
    696  * Obtain the `select()` sets for this daemon.
    697  * Daemon's FDs will be added to fd_sets. To get only
    698  * daemon FDs in fd_sets, call FD_ZERO for each fd_set
    699  * before calling this function. FD_SETSIZE is assumed
    700  * to be platform's default.
    701  *
    702  * This function should be called only when MHD is configured to
    703  * use "external" sockets polling with 'select()' or with 'epoll'.
    704  * In the latter case, it will only add the single 'epoll' file
    705  * descriptor used by MHD to the sets.
    706  * It's necessary to use #MHD_get_timeout() to get maximum timeout
    707  * value for `select()`. Usage of `select()` with indefinite timeout
    708  * (or timeout larger than returned by #MHD_get_timeout()) will
    709  * violate MHD API and may results in pending unprocessed data.
    710  *
    711  * This function must be called only for daemon started
    712  * without #MHD_USE_INTERNAL_POLLING_THREAD flag.
    713  *
    714  * @param daemon daemon to get sets from
    715  * @param read_fd_set read set
    716  * @param write_fd_set write set
    717  * @param except_fd_set except set
    718  * @param max_fd increased to largest FD added (if larger
    719  *               than existing value); can be NULL
    720  * @return #MHD_YES on success, #MHD_NO if this
    721  *         daemon was not started with the right
    722  *         options for this call or any FD didn't
    723  *         fit fd_set.
    724  * @ingroup event
    725  */
    726 _MHD_EXTERN enum MHD_Result
    727 MHD_get_fdset (struct MHD_Daemon *daemon,
    728                fd_set *read_fd_set,
    729                fd_set *write_fd_set,
    730                fd_set *except_fd_set,
    731                MHD_socket *max_fd)
    732 {
    733   return MHD_get_fdset2 (daemon,
    734                          read_fd_set,
    735                          write_fd_set,
    736                          except_fd_set,
    737                          max_fd,
    738 #ifdef HAS_FD_SETSIZE_OVERRIDABLE
    739                          daemon->fdset_size_set_by_app ?
    740                          ((unsigned int) daemon->fdset_size) :
    741                          ((unsigned int) _MHD_SYS_DEFAULT_FD_SETSIZE)
    742 #else  /* ! HAS_FD_SETSIZE_OVERRIDABLE */
    743                          ((unsigned int) _MHD_SYS_DEFAULT_FD_SETSIZE)
    744 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
    745                          );
    746 }
    747 
    748 
    749 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
    750 /**
    751  * Obtain the select() file descriptor sets for the
    752  * given @a urh.
    753  *
    754  * @param urh upgrade handle to wait for
    755  * @param[out] rs read set to initialize
    756  * @param[out] ws write set to initialize
    757  * @param[out] es except set to initialize
    758  * @param[out] max_fd maximum FD to update
    759  * @param fd_setsize value of FD_SETSIZE
    760  * @return true on success, false on error
    761  */
    762 static bool
    763 urh_to_fdset (struct MHD_UpgradeResponseHandle *urh,
    764               fd_set *rs,
    765               fd_set *ws,
    766               fd_set *es,
    767               MHD_socket *max_fd,
    768               int fd_setsize)
    769 {
    770   const MHD_socket conn_sckt = urh->connection->socket_fd;
    771   const MHD_socket mhd_sckt = urh->mhd.socket;
    772   bool res = true;
    773 
    774 #ifndef HAS_FD_SETSIZE_OVERRIDABLE
    775   (void) fd_setsize;  /* Mute compiler warning */
    776   fd_setsize = (int) FD_SETSIZE; /* Help compiler to optimise */
    777 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
    778 
    779   /* Do not add to 'es' only if socket is closed
    780    * or not used anymore. */
    781   if (MHD_INVALID_SOCKET != conn_sckt)
    782   {
    783     if ( (urh->in_buffer_used < urh->in_buffer_size) &&
    784          (! MHD_add_to_fd_set_ (conn_sckt,
    785                                 rs,
    786                                 max_fd,
    787                                 fd_setsize)) )
    788       res = false;
    789     if ( (0 != urh->out_buffer_used) &&
    790          (! MHD_add_to_fd_set_ (conn_sckt,
    791                                 ws,
    792                                 max_fd,
    793                                 fd_setsize)) )
    794       res = false;
    795     /* Do not monitor again for errors if error was detected before as
    796      * error state is remembered. */
    797     if ((0 == (urh->app.celi & MHD_EPOLL_STATE_ERROR)) &&
    798         ((0 != urh->in_buffer_size) ||
    799          (0 != urh->out_buffer_size) ||
    800          (0 != urh->out_buffer_used))
    801         && (NULL != es))
    802       (void) MHD_add_to_fd_set_ (conn_sckt,
    803                                  es,
    804                                  max_fd,
    805                                  fd_setsize);
    806   }
    807   if (MHD_INVALID_SOCKET != mhd_sckt)
    808   {
    809     if ( (urh->out_buffer_used < urh->out_buffer_size) &&
    810          (! MHD_add_to_fd_set_ (mhd_sckt,
    811                                 rs,
    812                                 max_fd,
    813                                 fd_setsize)) )
    814       res = false;
    815     if ( (0 != urh->in_buffer_used) &&
    816          (! MHD_add_to_fd_set_ (mhd_sckt,
    817                                 ws,
    818                                 max_fd,
    819                                 fd_setsize)) )
    820       res = false;
    821     /* Do not monitor again for errors if error was detected before as
    822      * error state is remembered. */
    823     if ((0 == (urh->mhd.celi & MHD_EPOLL_STATE_ERROR)) &&
    824         ((0 != urh->out_buffer_size) ||
    825          (0 != urh->in_buffer_size) ||
    826          (0 != urh->in_buffer_used))
    827         && (NULL != es))
    828       MHD_add_to_fd_set_ (mhd_sckt,
    829                           es,
    830                           max_fd,
    831                           fd_setsize);
    832   }
    833 
    834   return res;
    835 }
    836 
    837 
    838 /**
    839  * Update the @a urh based on the ready FDs in
    840  * the @a rs, @a ws, and @a es.
    841  *
    842  * @param urh upgrade handle to update
    843  * @param rs read result from select()
    844  * @param ws write result from select()
    845  * @param es except result from select()
    846  * @param fd_setsize value of FD_SETSIZE used when fd_sets were created
    847  */
    848 static void
    849 urh_from_fdset (struct MHD_UpgradeResponseHandle *urh,
    850                 const fd_set *rs,
    851                 const fd_set *ws,
    852                 const fd_set *es,
    853                 int fd_setsize)
    854 {
    855   const MHD_socket conn_sckt = urh->connection->socket_fd;
    856   const MHD_socket mhd_sckt = urh->mhd.socket;
    857 
    858   /* Reset read/write ready, preserve error state. */
    859   urh->app.celi &= (~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY)
    860                     & ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY));
    861   urh->mhd.celi &= (~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY)
    862                     & ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY));
    863 
    864   mhd_assert (urh->connection->sk_nonblck);
    865 
    866 #ifndef HAS_FD_SETSIZE_OVERRIDABLE
    867   (void) fd_setsize; /* Mute compiler warning */
    868   mhd_assert (((int) FD_SETSIZE) <= fd_setsize);
    869   fd_setsize = FD_SETSIZE; /* Help compiler to optimise */
    870 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
    871 
    872   if (MHD_INVALID_SOCKET != conn_sckt)
    873   {
    874     if (MHD_SCKT_FD_FITS_FDSET_SETSIZE_ (conn_sckt, NULL, fd_setsize))
    875     {
    876       if (FD_ISSET (conn_sckt, (fd_set *) _MHD_DROP_CONST (rs)))
    877         urh->app.celi |= MHD_EPOLL_STATE_READ_READY;
    878       if (FD_ISSET (conn_sckt, (fd_set *) _MHD_DROP_CONST (ws)))
    879         urh->app.celi |= MHD_EPOLL_STATE_WRITE_READY;
    880       if ((NULL != es) &&
    881           FD_ISSET (conn_sckt, (fd_set *) _MHD_DROP_CONST (es)))
    882         urh->app.celi |= MHD_EPOLL_STATE_ERROR;
    883     }
    884     else
    885     { /* Cannot check readiness. Force ready state is safe as socket is non-blocking */
    886       urh->app.celi |= MHD_EPOLL_STATE_READ_READY;
    887       urh->app.celi |= MHD_EPOLL_STATE_WRITE_READY;
    888     }
    889   }
    890   if ((MHD_INVALID_SOCKET != mhd_sckt))
    891   {
    892     if (MHD_SCKT_FD_FITS_FDSET_SETSIZE_ (mhd_sckt, NULL, fd_setsize))
    893     {
    894       if (FD_ISSET (mhd_sckt, (fd_set *) _MHD_DROP_CONST (rs)))
    895         urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
    896       if (FD_ISSET (mhd_sckt, (fd_set *) _MHD_DROP_CONST (ws)))
    897         urh->mhd.celi |= MHD_EPOLL_STATE_WRITE_READY;
    898       if ((NULL != es) &&
    899           FD_ISSET (mhd_sckt, (fd_set *) _MHD_DROP_CONST (es)))
    900         urh->mhd.celi |= MHD_EPOLL_STATE_ERROR;
    901     }
    902     else
    903     { /* Cannot check readiness. Force ready state is safe as socket is non-blocking */
    904       urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
    905       urh->mhd.celi |= MHD_EPOLL_STATE_WRITE_READY;
    906     }
    907   }
    908 }
    909 
    910 
    911 #ifdef HAVE_POLL
    912 
    913 /**
    914  * Set required 'event' members in 'pollfd' elements,
    915  * assuming that @a p[0].fd is MHD side of socketpair
    916  * and @a p[1].fd is TLS connected socket.
    917  *
    918  * @param urh upgrade handle to watch for
    919  * @param p pollfd array to update
    920  */
    921 static void
    922 urh_update_pollfd (struct MHD_UpgradeResponseHandle *urh,
    923                    struct pollfd p[2])
    924 {
    925   p[0].events = 0;
    926   p[1].events = 0;
    927 
    928   if (urh->in_buffer_used < urh->in_buffer_size)
    929     p[0].events |= POLLIN;
    930   if (0 != urh->out_buffer_used)
    931     p[0].events |= POLLOUT;
    932 
    933   /* Do not monitor again for errors if error was detected before as
    934    * error state is remembered. */
    935   if ((0 == (urh->app.celi & MHD_EPOLL_STATE_ERROR)) &&
    936       ((0 != urh->in_buffer_size) ||
    937        (0 != urh->out_buffer_size) ||
    938        (0 != urh->out_buffer_used)))
    939     p[0].events |= MHD_POLL_EVENTS_ERR_DISC;
    940 
    941   if (urh->out_buffer_used < urh->out_buffer_size)
    942     p[1].events |= POLLIN;
    943   if (0 != urh->in_buffer_used)
    944     p[1].events |= POLLOUT;
    945 
    946   /* Do not monitor again for errors if error was detected before as
    947    * error state is remembered. */
    948   if ((0 == (urh->mhd.celi & MHD_EPOLL_STATE_ERROR)) &&
    949       ((0 != urh->out_buffer_size) ||
    950        (0 != urh->in_buffer_size) ||
    951        (0 != urh->in_buffer_used)))
    952     p[1].events |= MHD_POLL_EVENTS_ERR_DISC;
    953 }
    954 
    955 
    956 /**
    957  * Set @a p to watch for @a urh.
    958  *
    959  * @param urh upgrade handle to watch for
    960  * @param p pollfd array to set
    961  */
    962 static void
    963 urh_to_pollfd (struct MHD_UpgradeResponseHandle *urh,
    964                struct pollfd p[2])
    965 {
    966   p[0].fd = urh->connection->socket_fd;
    967   p[1].fd = urh->mhd.socket;
    968   urh_update_pollfd (urh,
    969                      p);
    970 }
    971 
    972 
    973 /**
    974  * Update ready state in @a urh based on pollfd.
    975  * @param urh upgrade handle to update
    976  * @param p 'poll()' processed pollfd.
    977  */
    978 static void
    979 urh_from_pollfd (struct MHD_UpgradeResponseHandle *urh,
    980                  struct pollfd p[2])
    981 {
    982   /* Reset read/write ready, preserve error state. */
    983   urh->app.celi &= (~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY)
    984                     & ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY));
    985   urh->mhd.celi &= (~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY)
    986                     & ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY));
    987 
    988   if (0 != (p[0].revents & POLLIN))
    989     urh->app.celi |= MHD_EPOLL_STATE_READ_READY;
    990   if (0 != (p[0].revents & POLLOUT))
    991     urh->app.celi |= MHD_EPOLL_STATE_WRITE_READY;
    992   if (0 != (p[0].revents & POLLHUP))
    993     urh->app.celi |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
    994   if (0 != (p[0].revents & MHD_POLL_REVENTS_ERRROR))
    995     urh->app.celi |= MHD_EPOLL_STATE_ERROR;
    996   if (0 != (p[1].revents & POLLIN))
    997     urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
    998   if (0 != (p[1].revents & POLLOUT))
    999     urh->mhd.celi |= MHD_EPOLL_STATE_WRITE_READY;
   1000   if (0 != (p[1].revents & POLLHUP))
   1001     urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
   1002   if (0 != (p[1].revents & MHD_POLL_REVENTS_ERRROR))
   1003     urh->mhd.celi |= MHD_EPOLL_STATE_ERROR;
   1004 }
   1005 
   1006 
   1007 #endif /* HAVE_POLL */
   1008 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   1009 
   1010 
   1011 /**
   1012  * Internal version of #MHD_get_fdset2().
   1013  *
   1014  * @param daemon daemon to get sets from
   1015  * @param read_fd_set read set
   1016  * @param write_fd_set write set
   1017  * @param except_fd_set except set
   1018  * @param max_fd increased to largest FD added (if larger
   1019  *               than existing value); can be NULL
   1020  * @param fd_setsize value of FD_SETSIZE
   1021  * @return #MHD_YES on success, #MHD_NO if any FD didn't
   1022  *         fit fd_set.
   1023  * @ingroup event
   1024  */
   1025 static enum MHD_Result
   1026 internal_get_fdset2 (struct MHD_Daemon *daemon,
   1027                      fd_set *read_fd_set,
   1028                      fd_set *write_fd_set,
   1029                      fd_set *except_fd_set,
   1030                      MHD_socket *max_fd,
   1031                      int fd_setsize)
   1032 {
   1033   struct MHD_Connection *pos;
   1034   struct MHD_Connection *posn;
   1035   enum MHD_Result result = MHD_YES;
   1036   MHD_socket ls;
   1037   bool itc_added;
   1038 
   1039 #ifndef HAS_FD_SETSIZE_OVERRIDABLE
   1040   (void) fd_setsize;  /* Mute compiler warning */
   1041   fd_setsize = (int) FD_SETSIZE; /* Help compiler to optimise */
   1042 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   1043 
   1044   if (daemon->shutdown)
   1045     return MHD_YES;
   1046 
   1047   /* The order of FDs added is important for W32 sockets as W32 fd_set has
   1048      limits for number of added FDs instead of the limit for the higher
   1049      FD value. */
   1050 
   1051   /* Add ITC FD first. The daemon must be able to respond on application
   1052      commands issued in other threads. */
   1053   itc_added = false;
   1054   if (MHD_ITC_IS_VALID_ (daemon->itc))
   1055   {
   1056     itc_added = MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
   1057                                     read_fd_set,
   1058                                     max_fd,
   1059                                     fd_setsize);
   1060     if (! itc_added)
   1061       result = MHD_NO;
   1062   }
   1063 
   1064   ls = daemon->was_quiesced ? MHD_INVALID_SOCKET : daemon->listen_fd;
   1065   if (! itc_added &&
   1066       (MHD_INVALID_SOCKET != ls))
   1067   {
   1068     /* Add listen FD if ITC was not added. Listen FD could be used to signal
   1069        the daemon shutdown. */
   1070     if (MHD_add_to_fd_set_ (ls,
   1071                             read_fd_set,
   1072                             max_fd,
   1073                             fd_setsize))
   1074       ls = MHD_INVALID_SOCKET;   /* Already added */
   1075     else
   1076       result = MHD_NO;
   1077   }
   1078 
   1079   /* Add all sockets to 'except_fd_set' as well to watch for
   1080    * out-of-band data. However, ignore errors if INFO_READ
   1081    * or INFO_WRITE sockets will not fit 'except_fd_set'. */
   1082   /* Start from oldest connections. Make sense for W32 FDSETs. */
   1083   for (pos = daemon->connections_tail; NULL != pos; pos = posn)
   1084   {
   1085     posn = pos->prev;
   1086 
   1087     switch (pos->event_loop_info)
   1088     {
   1089     case MHD_EVENT_LOOP_INFO_READ:
   1090     case MHD_EVENT_LOOP_INFO_PROCESS_READ:
   1091       if (! MHD_add_to_fd_set_ (pos->socket_fd,
   1092                                 read_fd_set,
   1093                                 max_fd,
   1094                                 fd_setsize))
   1095         result = MHD_NO;
   1096 #ifdef MHD_POSIX_SOCKETS
   1097       if (NULL != except_fd_set)
   1098         (void) MHD_add_to_fd_set_ (pos->socket_fd,
   1099                                    except_fd_set,
   1100                                    max_fd,
   1101                                    fd_setsize);
   1102 #endif /* MHD_POSIX_SOCKETS */
   1103       break;
   1104     case MHD_EVENT_LOOP_INFO_WRITE:
   1105       if (! MHD_add_to_fd_set_ (pos->socket_fd,
   1106                                 write_fd_set,
   1107                                 max_fd,
   1108                                 fd_setsize))
   1109         result = MHD_NO;
   1110 #ifdef MHD_POSIX_SOCKETS
   1111       if (NULL != except_fd_set)
   1112         (void) MHD_add_to_fd_set_ (pos->socket_fd,
   1113                                    except_fd_set,
   1114                                    max_fd,
   1115                                    fd_setsize);
   1116 #endif /* MHD_POSIX_SOCKETS */
   1117       break;
   1118     case MHD_EVENT_LOOP_INFO_PROCESS:
   1119       if ( (NULL == except_fd_set) ||
   1120            ! MHD_add_to_fd_set_ (pos->socket_fd,
   1121                                  except_fd_set,
   1122                                  max_fd,
   1123                                  fd_setsize))
   1124         result = MHD_NO;
   1125       break;
   1126     case MHD_EVENT_LOOP_INFO_CLEANUP:
   1127       /* this should never happen */
   1128       break;
   1129     }
   1130   }
   1131 #ifdef MHD_WINSOCK_SOCKETS
   1132   /* W32 use limited array for fd_set so add INFO_READ/INFO_WRITE sockets
   1133    * only after INFO_BLOCK sockets to ensure that INFO_BLOCK sockets will
   1134    * not be pushed out. */
   1135   if (NULL != except_fd_set)
   1136   {
   1137     for (pos = daemon->connections_tail; NULL != pos; pos = posn)
   1138     {
   1139       posn = pos->prev;
   1140       MHD_add_to_fd_set_ (pos->socket_fd,
   1141                           except_fd_set,
   1142                           max_fd,
   1143                           fd_setsize);
   1144     }
   1145   }
   1146 #endif /* MHD_WINSOCK_SOCKETS */
   1147 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   1148   if (1)
   1149   {
   1150     struct MHD_UpgradeResponseHandle *urh;
   1151 
   1152     for (urh = daemon->urh_tail; NULL != urh; urh = urh->prev)
   1153     {
   1154       if (MHD_NO ==
   1155           urh_to_fdset (urh,
   1156                         read_fd_set,
   1157                         write_fd_set,
   1158                         except_fd_set,
   1159                         max_fd,
   1160                         fd_setsize))
   1161         result = MHD_NO;
   1162     }
   1163   }
   1164 #endif
   1165 
   1166   if (MHD_INVALID_SOCKET != ls)
   1167   {
   1168     /* The listen socket is present and hasn't been added */
   1169     if ((daemon->connections < daemon->connection_limit) &&
   1170         ! daemon->at_limit)
   1171     {
   1172       if (! MHD_add_to_fd_set_ (ls,
   1173                                 read_fd_set,
   1174                                 max_fd,
   1175                                 fd_setsize))
   1176         result = MHD_NO;
   1177     }
   1178   }
   1179 
   1180 #if _MHD_DEBUG_CONNECT
   1181 #ifdef HAVE_MESSAGES
   1182   if (NULL != max_fd)
   1183     MHD_DLOG (daemon,
   1184               _ ("Maximum socket in select set: %d\n"),
   1185               *max_fd);
   1186 #endif
   1187 #endif
   1188   return result;
   1189 }
   1190 
   1191 
   1192 /**
   1193  * Obtain the `select()` sets for this daemon.
   1194  * Daemon's FDs will be added to fd_sets. To get only
   1195  * daemon FDs in fd_sets, call FD_ZERO for each fd_set
   1196  * before calling this function.
   1197  *
   1198  * Passing custom FD_SETSIZE as @a fd_setsize allow usage of
   1199  * larger/smaller than platform's default fd_sets.
   1200  *
   1201  * This function should be called only when MHD is configured to
   1202  * use "external" sockets polling with 'select()' or with 'epoll'.
   1203  * In the latter case, it will only add the single 'epoll' file
   1204  * descriptor used by MHD to the sets.
   1205  * It's necessary to use #MHD_get_timeout() to get maximum timeout
   1206  * value for `select()`. Usage of `select()` with indefinite timeout
   1207  * (or timeout larger than returned by #MHD_get_timeout()) will
   1208  * violate MHD API and may results in pending unprocessed data.
   1209  *
   1210  * This function must be called only for daemon started
   1211  * without #MHD_USE_INTERNAL_POLLING_THREAD flag.
   1212  *
   1213  * @param daemon daemon to get sets from
   1214  * @param read_fd_set read set
   1215  * @param write_fd_set write set
   1216  * @param except_fd_set except set
   1217  * @param max_fd increased to largest FD added (if larger
   1218  *               than existing value); can be NULL
   1219  * @param fd_setsize value of FD_SETSIZE
   1220  * @return #MHD_YES on success, #MHD_NO if this
   1221  *         daemon was not started with the right
   1222  *         options for this call or any FD didn't
   1223  *         fit fd_set.
   1224  * @ingroup event
   1225  */
   1226 _MHD_EXTERN enum MHD_Result
   1227 MHD_get_fdset2 (struct MHD_Daemon *daemon,
   1228                 fd_set *read_fd_set,
   1229                 fd_set *write_fd_set,
   1230                 fd_set *except_fd_set,
   1231                 MHD_socket *max_fd,
   1232                 unsigned int fd_setsize)
   1233 {
   1234   if ( (NULL == daemon) ||
   1235        (NULL == read_fd_set) ||
   1236        (NULL == write_fd_set) ||
   1237        MHD_D_IS_USING_THREADS_ (daemon) ||
   1238        MHD_D_IS_USING_POLL_ (daemon))
   1239     return MHD_NO;
   1240 
   1241 #ifdef HAVE_MESSAGES
   1242   if (NULL == except_fd_set)
   1243   {
   1244     MHD_DLOG (daemon,
   1245               _ ("MHD_get_fdset2() called with except_fd_set "
   1246                  "set to NULL. Such behavior is unsupported.\n"));
   1247   }
   1248 #endif
   1249 
   1250 #ifdef HAS_FD_SETSIZE_OVERRIDABLE
   1251   if (0 == fd_setsize)
   1252     return MHD_NO;
   1253   else if (((unsigned int) INT_MAX) < fd_setsize)
   1254     fd_setsize = (unsigned int) INT_MAX;
   1255 #ifdef HAVE_MESSAGES
   1256   else if (daemon->fdset_size > ((int) fd_setsize))
   1257   {
   1258     if (daemon->fdset_size_set_by_app)
   1259     {
   1260       MHD_DLOG (daemon,
   1261                 _ ("%s() called with fd_setsize (%u) " \
   1262                    "less than value set by MHD_OPTION_APP_FD_SETSIZE (%d). " \
   1263                    "Some socket FDs may be not processed. " \
   1264                    "Use MHD_OPTION_APP_FD_SETSIZE with the correct value.\n"),
   1265                 "MHD_get_fdset2", fd_setsize, daemon->fdset_size);
   1266     }
   1267     else
   1268     {
   1269       MHD_DLOG (daemon,
   1270                 _ ("%s() called with fd_setsize (%u) " \
   1271                    "less than FD_SETSIZE used by MHD (%d). " \
   1272                    "Some socket FDs may be not processed. " \
   1273                    "Consider using MHD_OPTION_APP_FD_SETSIZE option.\n"),
   1274                 "MHD_get_fdset2", fd_setsize, daemon->fdset_size);
   1275     }
   1276   }
   1277 #endif /* HAVE_MESSAGES */
   1278 #else  /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   1279   if (((unsigned int) FD_SETSIZE) > fd_setsize)
   1280   {
   1281 #ifdef HAVE_MESSAGES
   1282     MHD_DLOG (daemon,
   1283               _ ("%s() called with fd_setsize (%u) " \
   1284                  "less than fixed FD_SETSIZE value (%d) used on the " \
   1285                  "platform.\n"),
   1286               "MHD_get_fdset2", fd_setsize, (int) FD_SETSIZE);
   1287 #endif /* HAVE_MESSAGES */
   1288     return MHD_NO;
   1289   }
   1290   fd_setsize = (int) FD_SETSIZE; /* Help compiler to optimise */
   1291 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   1292 
   1293 #ifdef EPOLL_SUPPORT
   1294   if (MHD_D_IS_USING_EPOLL_ (daemon))
   1295   {
   1296     if (daemon->shutdown)
   1297       return MHD_YES;
   1298 
   1299     /* we're in epoll mode, use the epoll FD as a stand-in for
   1300        the entire event set */
   1301 
   1302     return MHD_add_to_fd_set_ (daemon->epoll_fd,
   1303                                read_fd_set,
   1304                                max_fd,
   1305                                (int) fd_setsize) ? MHD_YES : MHD_NO;
   1306   }
   1307 #endif
   1308 
   1309   return internal_get_fdset2 (daemon,
   1310                               read_fd_set,
   1311                               write_fd_set,
   1312                               except_fd_set,
   1313                               max_fd,
   1314                               (int) fd_setsize);
   1315 }
   1316 
   1317 
   1318 /**
   1319  * Call the handlers for a connection in the appropriate order based
   1320  * on the readiness as detected by the event loop.
   1321  *
   1322  * @param con connection to handle
   1323  * @param read_ready set if the socket is ready for reading
   1324  * @param write_ready set if the socket is ready for writing
   1325  * @param force_close set if a hard error was detected on the socket;
   1326  *        if this information is not available, simply pass #MHD_NO
   1327  * @return #MHD_YES to continue normally,
   1328  *         #MHD_NO if a serious error was encountered and the
   1329  *         connection is to be closed.
   1330  */
   1331 static enum MHD_Result
   1332 call_handlers (struct MHD_Connection *con,
   1333                bool read_ready,
   1334                bool write_ready,
   1335                bool force_close)
   1336 {
   1337   enum MHD_Result ret;
   1338   bool states_info_processed = false;
   1339   /* Fast track flag */
   1340   bool on_fasttrack = (con->state == MHD_CONNECTION_INIT);
   1341   ret = MHD_YES;
   1342 
   1343   mhd_assert ((0 == (con->daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   1344               (MHD_thread_handle_ID_is_valid_ID_ (con->tid)));
   1345   mhd_assert ((0 != (con->daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   1346               (! MHD_thread_handle_ID_is_valid_ID_ (con->tid)));
   1347   mhd_assert ((0 == (con->daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   1348               (MHD_thread_handle_ID_is_current_thread_ (con->tid)));
   1349 
   1350 #ifdef HTTPS_SUPPORT
   1351   if (con->tls_read_ready)
   1352     read_ready = true;
   1353 #endif /* HTTPS_SUPPORT */
   1354   if (con->resumed)
   1355   {
   1356     /* The connection was resumed since its states were last updated,
   1357        so 'con->event_loop_info' still describes the state the
   1358        connection was in before it was suspended -- see the field's
   1359        description.  Dispatching on it would, for instance, call
   1360        MHD_connection_handle_write() on a connection whose content
   1361        reader has just reported that it has no data yet, which is not a
   1362        state the write handler has an action for. */
   1363     con->resumed = false;
   1364     ret = MHD_connection_handle_idle (con);
   1365     if (MHD_NO == ret)
   1366       return ret;  /* Connection died and was cleaned up. */
   1367     states_info_processed = true;
   1368   }
   1369   if ( (0 != (MHD_EVENT_LOOP_INFO_READ & con->event_loop_info)) &&
   1370        (read_ready || (force_close && con->sk_nonblck)) )
   1371   {
   1372     MHD_connection_handle_read (con, force_close);
   1373     /* MHD_connection_handle_read() closes the connection when
   1374        @a force_close is set, but only once it gets far enough to try.
   1375        It returns early, leaving 'con->state' untouched, in three cases,
   1376        and all three are reachable from here:
   1377          - the connection is suspended,
   1378          - a TLS handshake is still in progress,
   1379          - the read buffer has no free space at all. */
   1380 #ifdef HTTPS_SUPPORT
   1381     mhd_assert ((! force_close) || \
   1382                 (MHD_CONNECTION_CLOSED == con->state) || \
   1383                 (con->suspended) || \
   1384                 ( (MHD_TLS_CONN_NO_TLS != con->tls_state) && \
   1385                   (MHD_TLS_CONN_CONNECTED > con->tls_state) ) || \
   1386                 (con->read_buffer_size == con->read_buffer_offset));
   1387 #else  /* ! HTTPS_SUPPORT */
   1388     mhd_assert ((! force_close) || \
   1389                 (MHD_CONNECTION_CLOSED == con->state) || \
   1390                 (con->suspended) || \
   1391                 (con->read_buffer_size == con->read_buffer_offset));
   1392 #endif /* ! HTTPS_SUPPORT */
   1393     ret = MHD_connection_handle_idle (con);
   1394     if (force_close)
   1395       return ret;
   1396     states_info_processed = true;
   1397   }
   1398   if (! force_close)
   1399   {
   1400     /* No need to check value of 'ret' here as closed connection
   1401      * cannot be in MHD_EVENT_LOOP_INFO_WRITE state. */
   1402     if ( (MHD_EVENT_LOOP_INFO_WRITE == con->event_loop_info) &&
   1403          write_ready)
   1404     {
   1405       MHD_connection_handle_write (con);
   1406       ret = MHD_connection_handle_idle (con);
   1407       states_info_processed = true;
   1408     }
   1409   }
   1410   else
   1411   {
   1412     MHD_connection_close_ (con,
   1413                            MHD_REQUEST_TERMINATED_WITH_ERROR);
   1414     return MHD_connection_handle_idle (con);
   1415   }
   1416 
   1417   if (! states_info_processed)
   1418   {   /* Connection is not read or write ready, but external conditions
   1419        * may be changed and need to be processed. */
   1420     ret = MHD_connection_handle_idle (con);
   1421   }
   1422   /* Fast track for fast connections. */
   1423   /* If full request was read by single read_handler() invocation
   1424      and headers were completely prepared by single MHD_connection_handle_idle()
   1425      then try not to wait for next sockets polling and send response
   1426      immediately.
   1427      As writeability of socket was not checked and it may have
   1428      some data pending in system buffers, use this optimization
   1429      only for non-blocking sockets. */
   1430   /* No need to check 'ret' as connection is always in
   1431    * MHD_CONNECTION_CLOSED state if 'ret' is equal 'MHD_NO'. */
   1432   else if (on_fasttrack && con->sk_nonblck)
   1433   {
   1434     if (MHD_CONNECTION_HEADERS_SENDING == con->state)
   1435     {
   1436       MHD_connection_handle_write (con);
   1437       /* Always call 'MHD_connection_handle_idle()' after each read/write. */
   1438       ret = MHD_connection_handle_idle (con);
   1439     }
   1440     /* If all headers were sent by single write_handler() and
   1441      * response body is prepared by single MHD_connection_handle_idle()
   1442      * call - continue. */
   1443     if ((MHD_CONNECTION_NORMAL_BODY_READY == con->state) ||
   1444         (MHD_CONNECTION_CHUNKED_BODY_READY == con->state))
   1445     {
   1446       MHD_connection_handle_write (con);
   1447       ret = MHD_connection_handle_idle (con);
   1448     }
   1449   }
   1450 
   1451   /* All connection's data and states are processed for this turn.
   1452    * If connection already has more data to be processed - use
   1453    * zero timeout for next select()/poll(). */
   1454   /* Thread-per-connection do not need global zero timeout as
   1455    * connections are processed individually. */
   1456   /* Note: no need to check for read buffer availability for
   1457    * TLS read-ready connection in 'read info' state as connection
   1458    * without space in read buffer will be marked as 'info block'. */
   1459   if ( (! con->daemon->data_already_pending) &&
   1460        (! MHD_D_IS_USING_THREAD_PER_CONN_ (con->daemon)) )
   1461   {
   1462     if (0 != (MHD_EVENT_LOOP_INFO_PROCESS & con->event_loop_info))
   1463       con->daemon->data_already_pending = true;
   1464 #ifdef HTTPS_SUPPORT
   1465     else if ( (con->tls_read_ready) &&
   1466               (0 != (MHD_EVENT_LOOP_INFO_READ & con->event_loop_info)) )
   1467       con->daemon->data_already_pending = true;
   1468 #endif /* HTTPS_SUPPORT */
   1469   }
   1470   return ret;
   1471 }
   1472 
   1473 
   1474 #ifdef UPGRADE_SUPPORT
   1475 /**
   1476  * Finally cleanup upgrade-related resources. It should
   1477  * be called when TLS buffers have been drained and
   1478  * application signaled MHD by #MHD_UPGRADE_ACTION_CLOSE.
   1479  *
   1480  * @param connection handle to the upgraded connection to clean
   1481  */
   1482 static void
   1483 cleanup_upgraded_connection (struct MHD_Connection *connection)
   1484 {
   1485   struct MHD_UpgradeResponseHandle *urh = connection->urh;
   1486 
   1487   if (NULL == urh)
   1488     return;
   1489 #ifdef HTTPS_SUPPORT
   1490   /* Signal remote client the end of TLS connection by
   1491    * gracefully closing TLS session. */
   1492   if (0 != (connection->daemon->options & MHD_USE_TLS))
   1493     gnutls_bye (connection->tls_session,
   1494                 GNUTLS_SHUT_WR);
   1495 
   1496   if (MHD_INVALID_SOCKET != urh->mhd.socket)
   1497     MHD_socket_close_chk_ (urh->mhd.socket);
   1498 
   1499   if (MHD_INVALID_SOCKET != urh->app.socket)
   1500     MHD_socket_close_chk_ (urh->app.socket);
   1501 #endif /* HTTPS_SUPPORT */
   1502   connection->urh = NULL;
   1503   free (urh);
   1504 }
   1505 
   1506 
   1507 #endif /* UPGRADE_SUPPORT */
   1508 
   1509 
   1510 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   1511 /**
   1512  * Performs bi-directional forwarding on upgraded HTTPS connections
   1513  * based on the readiness state stored in the @a urh handle.
   1514  * @remark To be called only from thread that processes
   1515  * connection's recv(), send() and response.
   1516  *
   1517  * @param urh handle to process
   1518  */
   1519 static void
   1520 process_urh (struct MHD_UpgradeResponseHandle *urh)
   1521 {
   1522   /* Help compiler to optimize:
   1523    * pointers to 'connection' and 'daemon' are not changed
   1524    * during this processing, so no need to chain dereference
   1525    * each time. */
   1526   struct MHD_Connection *const connection = urh->connection;
   1527   struct MHD_Daemon *const daemon = connection->daemon;
   1528   /* Prevent data races: use same value of 'was_closed' throughout
   1529    * this function. If 'was_closed' changed externally in the middle
   1530    * of processing - it will be processed on next iteration. */
   1531   bool was_closed;
   1532 
   1533 #ifdef MHD_USE_THREADS
   1534   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   1535                MHD_thread_handle_ID_is_current_thread_ (connection->tid) );
   1536 #endif /* MHD_USE_THREADS */
   1537 
   1538   mhd_assert (0 != (daemon->options & MHD_USE_TLS));
   1539 
   1540   if (daemon->shutdown)
   1541   {
   1542     /* Daemon shutting down, application will not receive any more data. */
   1543 #ifdef HAVE_MESSAGES
   1544     if (! urh->was_closed)
   1545     {
   1546       MHD_DLOG (daemon,
   1547                 _ ("Initiated daemon shutdown while \"upgraded\" " \
   1548                    "connection was not closed.\n"));
   1549     }
   1550 #endif
   1551     urh->was_closed = true;
   1552   }
   1553   was_closed = urh->was_closed;
   1554   if (was_closed)
   1555   {
   1556     /* Application was closed connections: no more data
   1557      * can be forwarded to application socket. */
   1558     if (0 < urh->in_buffer_used)
   1559     {
   1560 #ifdef HAVE_MESSAGES
   1561       MHD_DLOG (daemon,
   1562                 _ ("Failed to forward to application %" PRIu64 \
   1563                    " bytes of data received from remote side: " \
   1564                    "application closed data forwarding.\n"),
   1565                 (uint64_t) urh->in_buffer_used);
   1566 #endif
   1567 
   1568     }
   1569     /* Discard any data received form remote. */
   1570     urh->in_buffer_used = 0;
   1571     /* Do not try to push data to application. */
   1572     urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY);
   1573     /* Reading from remote client is not required anymore. */
   1574     urh->in_buffer_size = 0;
   1575     urh->app.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1576     connection->tls_read_ready = false;
   1577   }
   1578 
   1579   /* On some platforms (W32, possibly Darwin) failed send() (send() will
   1580    * always fail after remote disconnect was detected) may discard data in
   1581    * system buffers received by system but not yet read by recv().  So, before
   1582    * trying send() on any socket, recv() must be performed at first otherwise
   1583    * last part of incoming data may be lost.  If disconnect or error was
   1584    * detected - try to read from socket to dry data possibly pending is system
   1585    * buffers. */
   1586 
   1587   /*
   1588    * handle reading from remote TLS client
   1589    */
   1590   if (((0 != ((MHD_EPOLL_STATE_ERROR | MHD_EPOLL_STATE_READ_READY)
   1591               & urh->app.celi)) ||
   1592        (connection->tls_read_ready)) &&
   1593       (urh->in_buffer_used < urh->in_buffer_size))
   1594   {
   1595     ssize_t res;
   1596     size_t buf_size;
   1597 
   1598     buf_size = urh->in_buffer_size - urh->in_buffer_used;
   1599     if (buf_size > SSIZE_MAX)
   1600       buf_size = SSIZE_MAX;
   1601 
   1602     res = gnutls_record_recv (connection->tls_session,
   1603                               &urh->in_buffer[urh->in_buffer_used],
   1604                               buf_size);
   1605     if (0 >= res)
   1606     {
   1607       connection->tls_read_ready = false;
   1608       if (GNUTLS_E_INTERRUPTED != res)
   1609       {
   1610         urh->app.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1611         if ((GNUTLS_E_AGAIN != res) ||
   1612             (0 != (MHD_EPOLL_STATE_ERROR & urh->app.celi)))
   1613         {
   1614           /* TLS unrecoverable error has been detected,
   1615              socket error was detected and all data has been read,
   1616              or socket was disconnected/shut down. */
   1617           /* Stop trying to read from this TLS socket. */
   1618           urh->in_buffer_size = 0;
   1619         }
   1620       }
   1621     }
   1622     else   /* 0 < res */
   1623     {
   1624       urh->in_buffer_used += (size_t) res;
   1625       connection->tls_read_ready =
   1626         (0 < gnutls_record_check_pending (connection->tls_session));
   1627     }
   1628   }
   1629 
   1630   /*
   1631    * handle reading from application
   1632    */
   1633   /* If application signalled MHD about socket closure then
   1634    * check for any pending data even if socket is not marked
   1635    * as 'ready' (signal may arrive after poll()/select()).
   1636    * Socketpair for forwarding is always in non-blocking mode
   1637    * so no risk that recv() will block the thread. */
   1638   if (((0 != ((MHD_EPOLL_STATE_ERROR | MHD_EPOLL_STATE_READ_READY)
   1639               & urh->mhd.celi))
   1640        || was_closed) /* Force last reading from app if app has closed the connection */
   1641       && (urh->out_buffer_used < urh->out_buffer_size))
   1642   {
   1643     ssize_t res;
   1644     size_t buf_size;
   1645 
   1646     buf_size = urh->out_buffer_size - urh->out_buffer_used;
   1647     if (buf_size > MHD_SCKT_SEND_MAX_SIZE_)
   1648       buf_size = MHD_SCKT_SEND_MAX_SIZE_;
   1649 
   1650     res = MHD_recv_ (urh->mhd.socket,
   1651                      &urh->out_buffer[urh->out_buffer_used],
   1652                      buf_size);
   1653     if (0 >= res)
   1654     {
   1655       const int err = MHD_socket_get_error_ ();
   1656       if ((0 == res) ||
   1657           ((! MHD_SCKT_ERR_IS_EINTR_ (err)) &&
   1658            (! MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err))))
   1659       {
   1660         urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1661         if ((0 == res) ||
   1662             (was_closed) ||
   1663             (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) ||
   1664             (! MHD_SCKT_ERR_IS_EAGAIN_ (err)))
   1665         {
   1666           /* Socket disconnect/shutdown was detected;
   1667            * Application signalled about closure of 'upgraded' socket and
   1668            * all data has been read from application;
   1669            * or persistent / unrecoverable error. */
   1670           /* Do not try to pull more data from application. */
   1671           urh->out_buffer_size = 0;
   1672         }
   1673       }
   1674     }
   1675     else   /* 0 < res */
   1676     {
   1677       urh->out_buffer_used += (size_t) res;
   1678       if (buf_size > (size_t) res)
   1679         urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1680     }
   1681   }
   1682 
   1683   /*
   1684    * handle writing to remote HTTPS client
   1685    */
   1686   if ( (0 != (MHD_EPOLL_STATE_WRITE_READY & urh->app.celi)) &&
   1687        (urh->out_buffer_used > 0) )
   1688   {
   1689     ssize_t res;
   1690     size_t data_size;
   1691 
   1692     data_size = urh->out_buffer_used;
   1693     if (data_size > SSIZE_MAX)
   1694       data_size = SSIZE_MAX;
   1695 
   1696     res = gnutls_record_send (connection->tls_session,
   1697                               urh->out_buffer,
   1698                               data_size);
   1699     if (0 >= res)
   1700     {
   1701       if (GNUTLS_E_INTERRUPTED != res)
   1702       {
   1703         urh->app.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY);
   1704         if (GNUTLS_E_AGAIN != res)
   1705         {
   1706           /* TLS connection shut down or
   1707            * persistent / unrecoverable error. */
   1708 #ifdef HAVE_MESSAGES
   1709           MHD_DLOG (daemon,
   1710                     _ ("Failed to forward to remote client %" PRIu64 \
   1711                        " bytes of data received from application: %s\n"),
   1712                     (uint64_t) urh->out_buffer_used,
   1713                     gnutls_strerror ((int) res));
   1714 #endif
   1715           /* Discard any data unsent to remote. */
   1716           urh->out_buffer_used = 0;
   1717           /* Do not try to pull more data from application. */
   1718           urh->out_buffer_size = 0;
   1719           urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1720         }
   1721       }
   1722     }
   1723     else   /* 0 < res */
   1724     {
   1725       const size_t next_out_buffer_used = urh->out_buffer_used - (size_t) res;
   1726       if (0 != next_out_buffer_used)
   1727       {
   1728         memmove (urh->out_buffer,
   1729                  &urh->out_buffer[res],
   1730                  next_out_buffer_used);
   1731       }
   1732       urh->out_buffer_used = next_out_buffer_used;
   1733     }
   1734     if ( (0 == urh->out_buffer_used) &&
   1735          (0 != (MHD_EPOLL_STATE_ERROR & urh->app.celi)) )
   1736     {
   1737       /* Unrecoverable error on socket was detected and all
   1738        * pending data was sent to remote. */
   1739       /* Do not try to send to remote anymore. */
   1740       urh->app.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY);
   1741       /* Do not try to pull more data from application. */
   1742       urh->out_buffer_size = 0;
   1743       urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1744     }
   1745   }
   1746 
   1747   /*
   1748    * handle writing to application
   1749    */
   1750   if ( (0 != (MHD_EPOLL_STATE_WRITE_READY & urh->mhd.celi)) &&
   1751        (urh->in_buffer_used > 0) )
   1752   {
   1753     ssize_t res;
   1754     size_t data_size;
   1755 
   1756     data_size = urh->in_buffer_used;
   1757     if (data_size > MHD_SCKT_SEND_MAX_SIZE_)
   1758       data_size = MHD_SCKT_SEND_MAX_SIZE_;
   1759 
   1760     res = MHD_send_ (urh->mhd.socket,
   1761                      urh->in_buffer,
   1762                      data_size);
   1763     if (0 >= res)
   1764     {
   1765       const int err = MHD_socket_get_error_ ();
   1766       if ( (! MHD_SCKT_ERR_IS_EINTR_ (err)) &&
   1767            (! MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err)) )
   1768       {
   1769         urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY);
   1770         if (! MHD_SCKT_ERR_IS_EAGAIN_ (err))
   1771         {
   1772           /* Socketpair connection shut down or
   1773            * persistent / unrecoverable error. */
   1774 #ifdef HAVE_MESSAGES
   1775           MHD_DLOG (daemon,
   1776                     _ ("Failed to forward to application %" PRIu64 \
   1777                        " bytes of data received from remote side: %s\n"),
   1778                     (uint64_t) urh->in_buffer_used,
   1779                     MHD_socket_strerr_ (err));
   1780 #endif
   1781           /* Discard any data received from remote. */
   1782           urh->in_buffer_used = 0;
   1783           /* Reading from remote client is not required anymore. */
   1784           urh->in_buffer_size = 0;
   1785           urh->app.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1786           connection->tls_read_ready = false;
   1787         }
   1788       }
   1789     }
   1790     else   /* 0 < res */
   1791     {
   1792       const size_t next_in_buffer_used = urh->in_buffer_used - (size_t) res;
   1793       if (0 != next_in_buffer_used)
   1794       {
   1795         memmove (urh->in_buffer,
   1796                  &urh->in_buffer[res],
   1797                  next_in_buffer_used);
   1798         if (data_size > (size_t) res)
   1799           urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY);
   1800       }
   1801       urh->in_buffer_used = next_in_buffer_used;
   1802     }
   1803     if ( (0 == urh->in_buffer_used) &&
   1804          (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) )
   1805     {
   1806       /* Do not try to push data to application. */
   1807       urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY);
   1808       /* Reading from remote client is not required anymore. */
   1809       urh->in_buffer_size = 0;
   1810       urh->app.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1811       connection->tls_read_ready = false;
   1812     }
   1813   }
   1814 
   1815   /* Check whether data is present in TLS buffers
   1816    * and incoming forward buffer have some space. */
   1817   if ( (connection->tls_read_ready) &&
   1818        (urh->in_buffer_used < urh->in_buffer_size) &&
   1819        (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon)) )
   1820     daemon->data_already_pending = true;
   1821 
   1822   if ( (daemon->shutdown) &&
   1823        ( (0 != urh->out_buffer_size) ||
   1824          (0 != urh->out_buffer_used) ) )
   1825   {
   1826     /* Daemon shutting down, discard any remaining forward data. */
   1827 #ifdef HAVE_MESSAGES
   1828     if (0 < urh->out_buffer_used)
   1829       MHD_DLOG (daemon,
   1830                 _ ("Failed to forward to remote client %" PRIu64 \
   1831                    " bytes of data received from application: daemon shut down.\n"),
   1832                 (uint64_t) urh->out_buffer_used);
   1833 #endif
   1834     /* Discard any data unsent to remote. */
   1835     urh->out_buffer_used = 0;
   1836     /* Do not try to sent to remote anymore. */
   1837     urh->app.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_WRITE_READY);
   1838     /* Do not try to pull more data from application. */
   1839     urh->out_buffer_size = 0;
   1840     urh->mhd.celi &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_READ_READY);
   1841   }
   1842 
   1843   if (! was_closed && urh->was_closed)
   1844     daemon->data_already_pending = true; /* Force processing again */
   1845 }
   1846 
   1847 
   1848 #endif /* HTTPS_SUPPORT  && UPGRADE_SUPPORT */
   1849 
   1850 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   1851 #ifdef UPGRADE_SUPPORT
   1852 /**
   1853  * Main function of the thread that handles an individual connection
   1854  * after it was "upgraded" when #MHD_USE_THREAD_PER_CONNECTION is set.
   1855  * @remark To be called only from thread that process
   1856  * connection's recv(), send() and response.
   1857  *
   1858  * @param con the connection this thread will handle
   1859  */
   1860 static void
   1861 thread_main_connection_upgrade (struct MHD_Connection *con)
   1862 {
   1863 #ifdef HTTPS_SUPPORT
   1864   struct MHD_UpgradeResponseHandle *urh = con->urh;
   1865   struct MHD_Daemon *daemon = con->daemon;
   1866 
   1867   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   1868                MHD_thread_handle_ID_is_current_thread_ (con->tid) );
   1869   /* Here, we need to bi-directionally forward
   1870      until the application tells us that it is done
   1871      with the socket; */
   1872   if ( (0 != (daemon->options & MHD_USE_TLS)) &&
   1873        MHD_D_IS_USING_SELECT_ (daemon))
   1874   {
   1875     while ( (0 != urh->in_buffer_size) ||
   1876             (0 != urh->out_buffer_size) ||
   1877             (0 != urh->in_buffer_used) ||
   1878             (0 != urh->out_buffer_used) )
   1879     {
   1880       /* use select */
   1881       fd_set rs;
   1882       fd_set ws;
   1883       fd_set es;
   1884       MHD_socket max_fd;
   1885       int num_ready;
   1886       bool result;
   1887 
   1888       FD_ZERO (&rs);
   1889       FD_ZERO (&ws);
   1890       FD_ZERO (&es);
   1891       max_fd = MHD_INVALID_SOCKET;
   1892       result = urh_to_fdset (urh,
   1893                              &rs,
   1894                              &ws,
   1895                              &es,
   1896                              &max_fd,
   1897                              FD_SETSIZE);
   1898       if (! result)
   1899       {
   1900 #ifdef HAVE_MESSAGES
   1901         MHD_DLOG (con->daemon,
   1902                   _ ("Error preparing select.\n"));
   1903 #endif
   1904         break;
   1905       }
   1906       /* FIXME: does this check really needed? */
   1907       if (MHD_INVALID_SOCKET != max_fd)
   1908       {
   1909         struct timeval *tvp;
   1910         struct timeval tv;
   1911         if (((con->tls_read_ready) &&
   1912              (urh->in_buffer_used < urh->in_buffer_size)) ||
   1913             (daemon->shutdown))
   1914         {         /* No need to wait if incoming data is already pending in TLS buffers. */
   1915           tv.tv_sec = 0;
   1916           tv.tv_usec = 0;
   1917           tvp = &tv;
   1918         }
   1919         else
   1920           tvp = NULL;
   1921         num_ready = MHD_SYS_select_ (max_fd + 1,
   1922                                      &rs,
   1923                                      &ws,
   1924                                      &es,
   1925                                      tvp);
   1926       }
   1927       else
   1928         num_ready = 0;
   1929       if (num_ready < 0)
   1930       {
   1931         const int err = MHD_socket_get_error_ ();
   1932 
   1933         if (MHD_SCKT_ERR_IS_EINTR_ (err))
   1934           continue;
   1935 #ifdef HAVE_MESSAGES
   1936         MHD_DLOG (con->daemon,
   1937                   _ ("Error during select (%d): `%s'\n"),
   1938                   err,
   1939                   MHD_socket_strerr_ (err));
   1940 #endif
   1941         break;
   1942       }
   1943       urh_from_fdset (urh,
   1944                       &rs,
   1945                       &ws,
   1946                       &es,
   1947                       (int) FD_SETSIZE);
   1948       process_urh (urh);
   1949     }
   1950   }
   1951 #ifdef HAVE_POLL
   1952   else if (0 != (daemon->options & MHD_USE_TLS))
   1953   {
   1954     /* use poll() */
   1955     struct pollfd p[2];
   1956     memset (p,
   1957             0,
   1958             sizeof (p));
   1959     p[0].fd = urh->connection->socket_fd;
   1960     p[1].fd = urh->mhd.socket;
   1961 
   1962     while ( (0 != urh->in_buffer_size) ||
   1963             (0 != urh->out_buffer_size) ||
   1964             (0 != urh->in_buffer_used) ||
   1965             (0 != urh->out_buffer_used) )
   1966     {
   1967       int timeout;
   1968 
   1969       urh_update_pollfd (urh, p);
   1970 
   1971       if (((con->tls_read_ready) &&
   1972            (urh->in_buffer_used < urh->in_buffer_size)) ||
   1973           (daemon->shutdown))
   1974         timeout = 0;     /* No need to wait if incoming data is already pending in TLS buffers. */
   1975       else
   1976         timeout = -1;
   1977 
   1978       if (MHD_sys_poll_ (p,
   1979                          2,
   1980                          timeout) < 0)
   1981       {
   1982         const int err = MHD_socket_get_error_ ();
   1983 
   1984         if (MHD_SCKT_ERR_IS_EINTR_ (err))
   1985           continue;
   1986 #ifdef HAVE_MESSAGES
   1987         MHD_DLOG (con->daemon,
   1988                   _ ("Error during poll: `%s'\n"),
   1989                   MHD_socket_strerr_ (err));
   1990 #endif
   1991         break;
   1992       }
   1993       urh_from_pollfd (urh,
   1994                        p);
   1995       process_urh (urh);
   1996     }
   1997   }
   1998   /* end POLL */
   1999 #endif
   2000   /* end HTTPS */
   2001 #endif /* HTTPS_SUPPORT */
   2002   /* TLS forwarding was finished. Cleanup socketpair. */
   2003   MHD_connection_finish_forward_ (con);
   2004   /* Do not set 'urh->clean_ready' yet as 'urh' will be used
   2005    * in connection thread for a little while. */
   2006 }
   2007 
   2008 
   2009 #endif /* UPGRADE_SUPPORT */
   2010 
   2011 
   2012 /**
   2013  * Get maximum wait period for the connection (the amount of time left before
   2014  * connection time out)
   2015  * @param c the connection to check
   2016  * @return the maximum number of millisecond before the connection must be
   2017  *         processed again.
   2018  */
   2019 static uint64_t
   2020 connection_get_wait (struct MHD_Connection *c)
   2021 {
   2022   const uint64_t now = MHD_monotonic_msec_counter ();
   2023   const uint64_t since_actv = now - c->last_activity;
   2024   const uint64_t timeout = c->connection_timeout_ms;
   2025   uint64_t mseconds_left;
   2026 
   2027   mhd_assert (0 != timeout);
   2028   /* Keep the next lines in sync with #connection_check_timedout() to avoid
   2029    * undesired side-effects like busy-waiting. */
   2030   if (timeout < since_actv)
   2031   {
   2032     if (UINT64_MAX / 2 < since_actv)
   2033     {
   2034       const uint64_t jump_back = c->last_activity - now;
   2035       /* Very unlikely that it is more than quarter-million years pause.
   2036        * More likely that system clock jumps back. */
   2037       if (5000 >= jump_back)
   2038       { /* Jump back is less than 5 seconds, try to recover. */
   2039         return 100; /* Set wait time to 0.1 seconds */
   2040       }
   2041       /* Too large jump back */
   2042     }
   2043     return 0; /* Connection has timed out */
   2044   }
   2045   else if (since_actv == timeout)
   2046   {
   2047     /* Exact match for timeout and time from last activity.
   2048      * Maybe this is just a precise match or this happens because the timer
   2049      * resolution is too low.
   2050      * Set wait time to 0.1 seconds to avoid busy-waiting with low
   2051      * timer resolution as connection is not timed-out yet. */
   2052     return 100;
   2053   }
   2054   mseconds_left = timeout - since_actv;
   2055 
   2056   return mseconds_left;
   2057 }
   2058 
   2059 
   2060 /**
   2061  * Complete the resume of a connection that has its own thread.
   2062  *
   2063  * This is the thread-per-connection counterpart of
   2064  * resume_suspended_connections(): the connection's own thread does the
   2065  * bookkeeping for itself instead of waiting for the daemon's thread to
   2066  * do it.  That is what makes the wake-up reliable -- the notification
   2067  * is sent to the connection's own ITC and is acted upon by the only
   2068  * thread that reads it, so it can neither be consumed by the daemon's
   2069  * thread nor be missed between the check of @e resuming and the wait.
   2070  *
   2071  * @param connection the suspended connection that is to be resumed,
   2072  *                   must have @e resuming set
   2073  */
   2074 static void
   2075 resume_connection_own_thread_ (struct MHD_Connection *connection)
   2076 {
   2077   struct MHD_Daemon *const daemon = connection->daemon;
   2078 
   2079   mhd_assert (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon));
   2080   mhd_assert (! MHD_D_IS_USING_EPOLL_ (daemon));
   2081 #ifdef UPGRADE_SUPPORT
   2082   mhd_assert (NULL == connection->urh);
   2083 #endif /* UPGRADE_SUPPORT */
   2084 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   2085   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   2086 #endif
   2087   mhd_assert (connection->suspended);
   2088   mhd_assert (connection->resuming);
   2089   DLL_remove (daemon->suspended_connections_head,
   2090               daemon->suspended_connections_tail,
   2091               connection);
   2092   connection->suspended = false;
   2093   DLL_insert (daemon->connections_head,
   2094               daemon->connections_tail,
   2095               connection);
   2096   connection->resuming = false;
   2097 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   2098   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   2099 #endif
   2100   /* Drop the notification that led here, as well as any notification
   2101      left over from a resume that was undone by a suspend before this
   2102      thread got to see it. */
   2103   MHD_itc_clear_ (connection->resume_itc);
   2104 }
   2105 
   2106 
   2107 /**
   2108  * Main function of the thread that handles an individual
   2109  * connection when #MHD_USE_THREAD_PER_CONNECTION is set.
   2110  *
   2111  * @param data the `struct MHD_Connection` this thread will handle
   2112  * @return always 0
   2113  */
   2114 static MHD_THRD_RTRN_TYPE_ MHD_THRD_CALL_SPEC_
   2115 thread_main_handle_connection (void *data)
   2116 {
   2117   struct MHD_Connection *con = data;
   2118   struct MHD_Daemon *daemon = con->daemon;
   2119   int num_ready;
   2120   fd_set rs;
   2121   fd_set ws;
   2122   fd_set es;
   2123   MHD_socket maxsock;
   2124 #ifdef WINDOWS
   2125 #ifdef HAVE_POLL
   2126   unsigned int extra_slot;
   2127 #endif /* HAVE_POLL */
   2128 #define EXTRA_SLOTS 1
   2129 #else  /* !WINDOWS */
   2130 #define EXTRA_SLOTS 0
   2131 #endif /* !WINDOWS */
   2132 #ifdef HAVE_POLL
   2133   struct pollfd p[1 + EXTRA_SLOTS];
   2134 #endif
   2135 #undef EXTRA_SLOTS
   2136 #ifdef HAVE_POLL
   2137   const bool use_poll = MHD_D_IS_USING_POLL_ (daemon);
   2138 #else  /* ! HAVE_POLL */
   2139   const bool use_poll = 0;
   2140 #endif /* ! HAVE_POLL */
   2141   bool was_suspended = false;
   2142   MHD_thread_handle_ID_set_current_thread_ID_ (&(con->tid));
   2143 
   2144   while ( (! daemon->shutdown) &&
   2145           (MHD_CONNECTION_CLOSED != con->state) )
   2146   {
   2147     bool use_zero_timeout;
   2148 #ifdef UPGRADE_SUPPORT
   2149     struct MHD_UpgradeResponseHandle *const urh = con->urh;
   2150 #else  /* ! UPGRADE_SUPPORT */
   2151     static const void *const urh = NULL;
   2152 #endif /* ! UPGRADE_SUPPORT */
   2153 
   2154     if ( (con->suspended) &&
   2155          (NULL == urh) )
   2156     {
   2157       /* Connection was suspended, wait for resume. */
   2158       was_suspended = true;
   2159       if (con->resuming)
   2160       {
   2161         /* The application resumed this connection.  Complete the resume
   2162            right here: this thread is the only one that handles this
   2163            connection, and doing it here is what keeps the wake-up below
   2164            free of lost-notification races. */
   2165         resume_connection_own_thread_ (con);
   2166         continue;
   2167       }
   2168       mhd_assert (MHD_ITC_IS_VALID_ (con->resume_itc));
   2169       if (! use_poll)
   2170       {
   2171         FD_ZERO (&rs);
   2172         if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (con->resume_itc),
   2173                                   &rs,
   2174                                   NULL,
   2175                                   FD_SETSIZE))
   2176         {
   2177   #ifdef HAVE_MESSAGES
   2178           MHD_DLOG (con->daemon,
   2179                     _ ("Failed to add FD to fd_set.\n"));
   2180   #endif
   2181           goto exit;
   2182         }
   2183         if (0 > MHD_SYS_select_ (MHD_itc_r_fd_ (con->resume_itc) + 1,
   2184                                  &rs,
   2185                                  NULL,
   2186                                  NULL,
   2187                                  NULL))
   2188         {
   2189           const int err = MHD_socket_get_error_ ();
   2190 
   2191           if (MHD_SCKT_ERR_IS_EINTR_ (err))
   2192             continue;
   2193 #ifdef HAVE_MESSAGES
   2194           MHD_DLOG (con->daemon,
   2195                     _ ("Error during select (%d): `%s'\n"),
   2196                     err,
   2197                     MHD_socket_strerr_ (err));
   2198 #endif
   2199           break;
   2200         }
   2201       }
   2202 #ifdef HAVE_POLL
   2203       else     /* use_poll */
   2204       {
   2205         p[0].events = POLLIN;
   2206         p[0].fd = MHD_itc_r_fd_ (con->resume_itc);
   2207         p[0].revents = 0;
   2208         if (0 > MHD_sys_poll_ (p,
   2209                                1,
   2210                                -1))
   2211         {
   2212           if (MHD_SCKT_LAST_ERR_IS_ (MHD_SCKT_EINTR_))
   2213             continue;
   2214 #ifdef HAVE_MESSAGES
   2215           MHD_DLOG (con->daemon,
   2216                     _ ("Error during poll: `%s'\n"),
   2217                     MHD_socket_last_strerr_ ());
   2218 #endif
   2219           break;
   2220         }
   2221       }
   2222 #endif /* HAVE_POLL */
   2223       MHD_itc_clear_ (con->resume_itc);
   2224       continue; /* Check again for resume. */
   2225     }           /* End of "suspended" branch. */
   2226 
   2227     if (was_suspended)
   2228     {
   2229       MHD_update_last_activity_ (con);     /* Reset timeout timer. */
   2230       /* Process response queued during suspend and update states. */
   2231       MHD_connection_handle_idle (con);
   2232       was_suspended = false;
   2233     }
   2234 
   2235     use_zero_timeout =
   2236       (0 != (MHD_EVENT_LOOP_INFO_PROCESS & con->event_loop_info)
   2237 #ifdef HTTPS_SUPPORT
   2238        || ( (con->tls_read_ready) &&
   2239             (0 != (MHD_EVENT_LOOP_INFO_READ & con->event_loop_info)) )
   2240 #endif /* HTTPS_SUPPORT */
   2241       );
   2242     if (! use_poll)
   2243     {
   2244       /* use select */
   2245       bool err_state = false;
   2246       struct timeval tv;
   2247       struct timeval *tvp;
   2248       if (use_zero_timeout)
   2249       {
   2250         tv.tv_sec = 0;
   2251         tv.tv_usec = 0;
   2252         tvp = &tv;
   2253       }
   2254       else if (con->connection_timeout_ms > 0)
   2255       {
   2256         const uint64_t mseconds_left = connection_get_wait (con);
   2257 #if (SIZEOF_UINT64_T - 2) >= SIZEOF_STRUCT_TIMEVAL_TV_SEC
   2258         if (mseconds_left / 1000 > TIMEVAL_TV_SEC_MAX)
   2259           tv.tv_sec = TIMEVAL_TV_SEC_MAX;
   2260         else
   2261 #endif /* (SIZEOF_UINT64_T - 2) >= SIZEOF_STRUCT_TIMEVAL_TV_SEC */
   2262         tv.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE) mseconds_left / 1000;
   2263 
   2264         tv.tv_usec = ((uint16_t) (mseconds_left % 1000)) * ((int32_t) 1000);
   2265         tvp = &tv;
   2266       }
   2267       else
   2268         tvp = NULL;
   2269 
   2270       FD_ZERO (&rs);
   2271       FD_ZERO (&ws);
   2272       FD_ZERO (&es);
   2273       maxsock = MHD_INVALID_SOCKET;
   2274       switch (con->event_loop_info)
   2275       {
   2276       case MHD_EVENT_LOOP_INFO_READ:
   2277       case MHD_EVENT_LOOP_INFO_PROCESS_READ:
   2278         if (! MHD_add_to_fd_set_ (con->socket_fd,
   2279                                   &rs,
   2280                                   &maxsock,
   2281                                   FD_SETSIZE))
   2282           err_state = true;
   2283         break;
   2284       case MHD_EVENT_LOOP_INFO_WRITE:
   2285         if (! MHD_add_to_fd_set_ (con->socket_fd,
   2286                                   &ws,
   2287                                   &maxsock,
   2288                                   FD_SETSIZE))
   2289           err_state = true;
   2290         break;
   2291       case MHD_EVENT_LOOP_INFO_PROCESS:
   2292         if (! MHD_add_to_fd_set_ (con->socket_fd,
   2293                                   &es,
   2294                                   &maxsock,
   2295                                   FD_SETSIZE))
   2296           err_state = true;
   2297         break;
   2298       case MHD_EVENT_LOOP_INFO_CLEANUP:
   2299         /* how did we get here!? */
   2300         goto exit;
   2301       }
   2302 #ifdef WINDOWS
   2303       if (MHD_ITC_IS_VALID_ (daemon->itc) )
   2304       {
   2305         if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
   2306                                   &rs,
   2307                                   &maxsock,
   2308                                   FD_SETSIZE))
   2309           err_state = 1;
   2310       }
   2311 #endif
   2312       if (err_state)
   2313       {
   2314 #ifdef HAVE_MESSAGES
   2315         MHD_DLOG (con->daemon,
   2316                   _ ("Failed to add FD to fd_set.\n"));
   2317 #endif
   2318         goto exit;
   2319       }
   2320 
   2321       num_ready = MHD_SYS_select_ (maxsock + 1,
   2322                                    &rs,
   2323                                    &ws,
   2324                                    &es,
   2325                                    tvp);
   2326       if (num_ready < 0)
   2327       {
   2328         const int err = MHD_socket_get_error_ ();
   2329 
   2330         if (MHD_SCKT_ERR_IS_EINTR_ (err))
   2331           continue;
   2332 #ifdef HAVE_MESSAGES
   2333         MHD_DLOG (con->daemon,
   2334                   _ ("Error during select (%d): `%s'\n"),
   2335                   err,
   2336                   MHD_socket_strerr_ (err));
   2337 #endif
   2338         break;
   2339       }
   2340 #ifdef WINDOWS
   2341       /* Clear ITC before other processing so additional
   2342        * signals will trigger select() again */
   2343       if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
   2344            (FD_ISSET (MHD_itc_r_fd_ (daemon->itc),
   2345                       &rs)) )
   2346         MHD_itc_clear_ (daemon->itc);
   2347 #endif
   2348       if (MHD_NO ==
   2349           call_handlers (con,
   2350                          FD_ISSET (con->socket_fd,
   2351                                    &rs),
   2352                          FD_ISSET (con->socket_fd,
   2353                                    &ws),
   2354                          FD_ISSET (con->socket_fd,
   2355                                    &es)) )
   2356         goto exit;
   2357     }
   2358 #ifdef HAVE_POLL
   2359     else
   2360     {
   2361       int timeout_val;
   2362       /* use poll */
   2363       if (use_zero_timeout)
   2364         timeout_val = 0;
   2365       else if (con->connection_timeout_ms > 0)
   2366       {
   2367         const uint64_t mseconds_left = connection_get_wait (con);
   2368 #if SIZEOF_UINT64_T >= SIZEOF_INT
   2369         if (mseconds_left >= INT_MAX)
   2370           timeout_val = INT_MAX;
   2371         else
   2372 #endif /* SIZEOF_UINT64_T >= SIZEOF_INT */
   2373         timeout_val = (int) mseconds_left;
   2374       }
   2375       else
   2376         timeout_val = -1;
   2377       memset (&p,
   2378               0,
   2379               sizeof (p));
   2380       p[0].fd = con->socket_fd;
   2381       switch (con->event_loop_info)
   2382       {
   2383       case MHD_EVENT_LOOP_INFO_READ:
   2384       case MHD_EVENT_LOOP_INFO_PROCESS_READ:
   2385         p[0].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
   2386         break;
   2387       case MHD_EVENT_LOOP_INFO_WRITE:
   2388         p[0].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
   2389         break;
   2390       case MHD_EVENT_LOOP_INFO_PROCESS:
   2391         p[0].events |= MHD_POLL_EVENTS_ERR_DISC;
   2392         break;
   2393       case MHD_EVENT_LOOP_INFO_CLEANUP:
   2394         /* how did we get here!? */
   2395         goto exit;
   2396       }
   2397 #ifdef WINDOWS
   2398       extra_slot = 0;
   2399       if (MHD_ITC_IS_VALID_ (daemon->itc))
   2400       {
   2401         p[1].events |= POLLIN;
   2402         p[1].fd = MHD_itc_r_fd_ (daemon->itc);
   2403         p[1].revents = 0;
   2404         extra_slot = 1;
   2405       }
   2406 #endif
   2407       if (MHD_sys_poll_ (p,
   2408 #ifdef WINDOWS
   2409                          1 + extra_slot,
   2410 #else
   2411                          1,
   2412 #endif
   2413                          timeout_val) < 0)
   2414       {
   2415         if (MHD_SCKT_LAST_ERR_IS_ (MHD_SCKT_EINTR_))
   2416           continue;
   2417 #ifdef HAVE_MESSAGES
   2418         MHD_DLOG (con->daemon,
   2419                   _ ("Error during poll: `%s'\n"),
   2420                   MHD_socket_last_strerr_ ());
   2421 #endif
   2422         break;
   2423       }
   2424 #ifdef WINDOWS
   2425       /* Clear ITC before other processing so additional
   2426        * signals will trigger poll() again */
   2427       if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
   2428            (0 != (p[1].revents & (POLLERR | POLLHUP | POLLIN))) )
   2429         MHD_itc_clear_ (daemon->itc);
   2430 #endif
   2431       if (MHD_NO ==
   2432           call_handlers (con,
   2433                          (0 != (p[0].revents & POLLIN)),
   2434                          (0 != (p[0].revents & POLLOUT)),
   2435                          (0 != (p[0].revents & MHD_POLL_REVENTS_ERR_DISC)) ))
   2436         goto exit;
   2437     }
   2438 #endif
   2439 #ifdef UPGRADE_SUPPORT
   2440     if (MHD_CONNECTION_UPGRADE == con->state)
   2441     {
   2442       /* Normal HTTP processing is finished,
   2443        * notify application. */
   2444       if ( (NULL != daemon->notify_completed) &&
   2445            (con->rq.client_aware) )
   2446         daemon->notify_completed (daemon->notify_completed_cls,
   2447                                   con,
   2448                                   &con->rq.client_context,
   2449                                   MHD_REQUEST_TERMINATED_COMPLETED_OK);
   2450       con->rq.client_aware = false;
   2451 
   2452       thread_main_connection_upgrade (con);
   2453       /* MHD_connection_finish_forward_() was called by thread_main_connection_upgrade(). */
   2454 
   2455       /* "Upgraded" data will not be used in this thread from this point. */
   2456       con->urh->clean_ready = true;
   2457       /* If 'urh->was_closed' set to true, connection will be
   2458        * moved immediately to cleanup list. Otherwise connection
   2459        * will stay in suspended list until 'urh' will be marked
   2460        * with 'was_closed' by application. */
   2461       MHD_resume_connection (con);
   2462 
   2463       /* skip usual clean up  */
   2464       return (MHD_THRD_RTRN_TYPE_) 0;
   2465     }
   2466 #endif /* UPGRADE_SUPPORT */
   2467   }
   2468 #if _MHD_DEBUG_CLOSE
   2469 #ifdef HAVE_MESSAGES
   2470   MHD_DLOG (con->daemon,
   2471             _ ("Processing thread terminating. Closing connection.\n"));
   2472 #endif
   2473 #endif
   2474   if (MHD_CONNECTION_CLOSED != con->state)
   2475     MHD_connection_close_ (con,
   2476                            (daemon->shutdown) ?
   2477                            MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN :
   2478                            MHD_REQUEST_TERMINATED_WITH_ERROR);
   2479   MHD_connection_handle_idle (con);
   2480 exit:
   2481   if (NULL != con->rp.response)
   2482   {
   2483     MHD_destroy_response (con->rp.response);
   2484     con->rp.response = NULL;
   2485   }
   2486 
   2487   if (MHD_INVALID_SOCKET != con->socket_fd)
   2488   {
   2489     shutdown (con->socket_fd,
   2490               SHUT_WR);
   2491     /* 'socket_fd' can be used in other thread to signal shutdown.
   2492      * To avoid data races, do not close socket here. Daemon will
   2493      * use more connections only after cleanup anyway. */
   2494   }
   2495   if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
   2496        (! MHD_itc_activate_ (daemon->itc, "t")) )
   2497   {
   2498 #ifdef HAVE_MESSAGES
   2499     MHD_DLOG (daemon,
   2500               _ ("Failed to signal thread termination via inter-thread " \
   2501                  "communication channel.\n"));
   2502 #endif
   2503   }
   2504   return (MHD_THRD_RTRN_TYPE_) 0;
   2505 }
   2506 
   2507 
   2508 #endif
   2509 
   2510 
   2511 /**
   2512  * Free resources associated with all closed connections.
   2513  * (destroy responses, free buffers, etc.).  All closed
   2514  * connections are kept in the "cleanup" doubly-linked list.
   2515  *
   2516  * @param daemon daemon to clean up
   2517  */
   2518 static void
   2519 MHD_cleanup_connections (struct MHD_Daemon *daemon);
   2520 
   2521 #if defined(HTTPS_SUPPORT)
   2522 #if defined(MHD_SEND_SPIPE_SUPPRESS_NEEDED) && \
   2523   defined(MHD_SEND_SPIPE_SUPPRESS_POSSIBLE) && \
   2524   ! defined(MHD_socket_nosignal_) && \
   2525   (GNUTLS_VERSION_NUMBER + 0 < 0x030402) && defined(MSG_NOSIGNAL)
   2526 /**
   2527  * Older version of GnuTLS do not support suppressing of SIGPIPE signal.
   2528  * Use push function replacement with suppressing SIGPIPE signal where necessary
   2529  * and if possible.
   2530  */
   2531 #define MHD_TLSLIB_NEED_PUSH_FUNC 1
   2532 #endif /* MHD_SEND_SPIPE_SUPPRESS_NEEDED &&
   2533           MHD_SEND_SPIPE_SUPPRESS_POSSIBLE &&
   2534           ! MHD_socket_nosignal_ && (GNUTLS_VERSION_NUMBER+0 < 0x030402) &&
   2535           MSG_NOSIGNAL */
   2536 
   2537 #ifdef MHD_TLSLIB_NEED_PUSH_FUNC
   2538 /**
   2539  * Data push function replacement with suppressing SIGPIPE signal
   2540  * for TLS library.
   2541  */
   2542 static ssize_t
   2543 MHD_tls_push_func_ (gnutls_transport_ptr_t trnsp,
   2544                     const void *data,
   2545                     size_t data_size)
   2546 {
   2547 #if (MHD_SCKT_SEND_MAX_SIZE_ < SSIZE_MAX) || (0 == SSIZE_MAX)
   2548   if (data_size > MHD_SCKT_SEND_MAX_SIZE_)
   2549     data_size = MHD_SCKT_SEND_MAX_SIZE_;
   2550 #endif /* (MHD_SCKT_SEND_MAX_SIZE_ < SSIZE_MAX) || (0 == SSIZE_MAX) */
   2551   return MHD_send_ ((MHD_socket) (intptr_t) (trnsp), data, data_size);
   2552 }
   2553 
   2554 
   2555 #endif /* MHD_TLSLIB_DONT_SUPPRESS_SIGPIPE */
   2556 
   2557 
   2558 /**
   2559  * The shortest pre-shared key #MHD_OPTION_GNUTLS_PSK_CRED_HANDLER may
   2560  * hand back, in bytes.  RFC 4279 section 7.1 requires at least 16 bytes
   2561  * of entropy in a PSK and recommends the length of the hash of the
   2562  * negotiated cipher suite; anything shorter is brute-forceable offline
   2563  * from a single recorded handshake, so MHD refuses it rather than let
   2564  * the application weaken the connection by accident.
   2565  */
   2566 #define MHD_PSK_MIN_SIZE 16
   2567 
   2568 /**
   2569  * Function called by GNUtls to obtain the PSK for a given session.
   2570  *
   2571  * @param session the session to lookup PSK for
   2572  * @param username username to lookup PSK for
   2573  * @param[out] key where to write PSK
   2574  * @return 0 on success, -1 on error
   2575  */
   2576 static int
   2577 psk_gnutls_adapter (gnutls_session_t session,
   2578                     const char *username,
   2579                     gnutls_datum_t *key)
   2580 {
   2581   struct MHD_Connection *connection;
   2582   struct MHD_Daemon *daemon;
   2583 #if GNUTLS_VERSION_MAJOR >= 3
   2584   void *app_psk;
   2585   size_t app_psk_size;
   2586 #endif /* GNUTLS_VERSION_MAJOR >= 3 */
   2587 
   2588   connection = gnutls_session_get_ptr (session);
   2589   if (NULL == connection)
   2590   {
   2591 #ifdef HAVE_MESSAGES
   2592     /* Cannot use our logger, we don't even have "daemon" */
   2593     MHD_PANIC (_ ("Internal server error. This should be impossible.\n"));
   2594 #endif
   2595     return -1;
   2596   }
   2597   daemon = connection->daemon;
   2598 #if GNUTLS_VERSION_MAJOR >= 3
   2599   if (NULL == daemon->cred_callback)
   2600   {
   2601 #ifdef HAVE_MESSAGES
   2602     MHD_DLOG (daemon,
   2603               _ ("PSK not supported by this server.\n"));
   2604 #endif
   2605     return -1;
   2606   }
   2607   if (0 != daemon->cred_callback (daemon->cred_callback_cls,
   2608                                   connection,
   2609                                   username,
   2610                                   &app_psk,
   2611                                   &app_psk_size))
   2612     return -1;
   2613   if (MHD_PSK_MIN_SIZE > app_psk_size)
   2614   {
   2615 #ifdef HAVE_MESSAGES
   2616     MHD_DLOG (daemon,
   2617               _ ("PSK authentication failed: PSK too short.\n"));
   2618 #endif
   2619     free (app_psk);
   2620     return -1;
   2621   }
   2622   if (UINT_MAX < app_psk_size)
   2623   {
   2624 #ifdef HAVE_MESSAGES
   2625     MHD_DLOG (daemon,
   2626               _ ("PSK authentication failed: PSK too long.\n"));
   2627 #endif
   2628     free (app_psk);
   2629     return -1;
   2630   }
   2631   /* @a app_psk_size is at least MHD_PSK_MIN_SIZE here, so this is never
   2632      gnutls_malloc(0) -- whose result is implementation defined and would
   2633      be reported below as an allocation failure. */
   2634   if (NULL == (key->data = gnutls_malloc (app_psk_size)))
   2635   {
   2636 #ifdef HAVE_MESSAGES
   2637     MHD_DLOG (daemon,
   2638               _ ("PSK authentication failed: gnutls_malloc failed to " \
   2639                  "allocate memory.\n"));
   2640 #endif
   2641     free (app_psk);
   2642     return -1;
   2643   }
   2644   key->size = (unsigned int) app_psk_size;
   2645   memcpy (key->data,
   2646           app_psk,
   2647           app_psk_size);
   2648   free (app_psk);
   2649   return 0;
   2650 #else
   2651   (void) username; (void) key; /* Mute compiler warning */
   2652 #ifdef HAVE_MESSAGES
   2653   MHD_DLOG (daemon,
   2654             _ ("PSK not supported by this server.\n"));
   2655 #endif
   2656   return -1;
   2657 #endif
   2658 }
   2659 
   2660 
   2661 #endif /* HTTPS_SUPPORT */
   2662 
   2663 
   2664 /**
   2665  * Do basic preparation work on the new incoming connection.
   2666  *
   2667  * This function do all preparation that is possible outside main daemon
   2668  * thread.
   2669  * @remark Could be called from any thread.
   2670  *
   2671  * @param daemon daemon that manages the connection
   2672  * @param client_socket socket to manage (MHD will expect
   2673  *        to receive an HTTP request from this socket next).
   2674  * @param addr IP address of the client
   2675  * @param addrlen number of bytes in @a addr
   2676  * @param external_add indicate that socket has been added externally
   2677  * @param non_blck indicate that socket in non-blocking mode
   2678  * @param sk_spipe_supprs indicate that the @a client_socket has
   2679  *                         set SIGPIPE suppression
   2680  * @param sk_is_nonip _MHD_YES if this is not a TCP/IP socket
   2681  * @return pointer to the connection on success, NULL if this daemon could
   2682  *        not handle the connection (i.e. malloc failed, etc).
   2683  *        The socket will be closed in case of error; 'errno' is
   2684  *        set to indicate further details about the error.
   2685  */
   2686 static struct MHD_Connection *
   2687 new_connection_prepare_ (struct MHD_Daemon *daemon,
   2688                          MHD_socket client_socket,
   2689                          const struct sockaddr_storage *addr,
   2690                          socklen_t addrlen,
   2691                          bool external_add,
   2692                          bool non_blck,
   2693                          bool sk_spipe_supprs,
   2694                          enum MHD_tristate sk_is_nonip)
   2695 {
   2696   struct MHD_Connection *connection;
   2697   int eno = 0;
   2698 
   2699 #ifdef HAVE_MESSAGES
   2700 #if _MHD_DEBUG_CONNECT
   2701   MHD_DLOG (daemon,
   2702             _ ("Accepted connection on socket %d.\n"),
   2703             client_socket);
   2704 #endif
   2705 #endif
   2706   if ( (daemon->connections == daemon->connection_limit) ||
   2707        (MHD_NO == MHD_ip_limit_add (daemon,
   2708                                     addr,
   2709                                     addrlen)) )
   2710   {
   2711     /* above connection limit - reject */
   2712 #ifdef HAVE_MESSAGES
   2713     MHD_DLOG (daemon,
   2714               _ ("Server reached connection limit. " \
   2715                  "Closing inbound connection.\n"));
   2716 #endif
   2717     MHD_socket_close_chk_ (client_socket);
   2718 #if defined(ENFILE) && (ENFILE + 0 != 0)
   2719     errno = ENFILE;
   2720 #endif
   2721     return NULL;
   2722   }
   2723 
   2724   /* apply connection acceptance policy if present */
   2725   if ( (NULL != daemon->apc) &&
   2726        (MHD_NO == daemon->apc (daemon->apc_cls,
   2727                                (const struct sockaddr *) addr,
   2728                                addrlen)) )
   2729   {
   2730 #if _MHD_DEBUG_CLOSE
   2731 #ifdef HAVE_MESSAGES
   2732     MHD_DLOG (daemon,
   2733               _ ("Connection rejected by application. Closing connection.\n"));
   2734 #endif
   2735 #endif
   2736     MHD_socket_close_chk_ (client_socket);
   2737     MHD_ip_limit_del (daemon,
   2738                       addr,
   2739                       addrlen);
   2740 #if defined(EACCESS) && (EACCESS + 0 != 0)
   2741     errno = EACCESS;
   2742 #endif
   2743     return NULL;
   2744   }
   2745 
   2746   if (NULL == (connection = MHD_calloc_ (1, sizeof (struct MHD_Connection))))
   2747   {
   2748     eno = errno;
   2749 #ifdef HAVE_MESSAGES
   2750     MHD_DLOG (daemon,
   2751               _ ("Error allocating memory: %s\n"),
   2752               MHD_strerror_ (errno));
   2753 #endif
   2754     MHD_socket_close_chk_ (client_socket);
   2755     MHD_ip_limit_del (daemon,
   2756                       addr,
   2757                       addrlen);
   2758     errno = eno;
   2759     return NULL;
   2760   }
   2761 
   2762   if (! external_add)
   2763   {
   2764     connection->sk_corked = _MHD_OFF;
   2765     connection->sk_nodelay = _MHD_OFF;
   2766   }
   2767   else
   2768   {
   2769     connection->sk_corked = _MHD_UNKNOWN;
   2770     connection->sk_nodelay = _MHD_UNKNOWN;
   2771   }
   2772 
   2773   if (0 < addrlen)
   2774   {
   2775     if (NULL == (connection->addr = malloc ((size_t) addrlen)))
   2776     {
   2777       eno = errno;
   2778 #ifdef HAVE_MESSAGES
   2779       MHD_DLOG (daemon,
   2780                 _ ("Error allocating memory: %s\n"),
   2781                 MHD_strerror_ (errno));
   2782 #endif
   2783       MHD_socket_close_chk_ (client_socket);
   2784       MHD_ip_limit_del (daemon,
   2785                         addr,
   2786                         addrlen);
   2787       free (connection);
   2788       errno = eno;
   2789       return NULL;
   2790     }
   2791     memcpy (connection->addr,
   2792             addr,
   2793             (size_t) addrlen);
   2794   }
   2795   else
   2796     connection->addr = NULL;
   2797   connection->addr_len = addrlen;
   2798   connection->socket_fd = client_socket;
   2799   connection->sk_nonblck = non_blck;
   2800   connection->is_nonip = sk_is_nonip;
   2801   connection->sk_spipe_suppress = sk_spipe_supprs;
   2802 #ifdef MHD_USE_THREADS
   2803   MHD_thread_handle_ID_set_invalid_ (&connection->tid);
   2804 #endif /* MHD_USE_THREADS */
   2805   connection->daemon = daemon;
   2806   connection->connection_timeout_ms = daemon->connection_timeout_ms;
   2807   connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
   2808   if (0 != connection->connection_timeout_ms)
   2809     connection->last_activity = MHD_monotonic_msec_counter ();
   2810 
   2811   MHD_itc_set_invalid_ (connection->resume_itc);
   2812   if ( (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon)) &&
   2813        (0 != (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME)) &&
   2814        (! MHD_itc_init_ (connection->resume_itc)) )
   2815   {
   2816     eno = errno;
   2817 #ifdef HAVE_MESSAGES
   2818     MHD_DLOG (daemon,
   2819               _ ("Failed to create inter-thread communication channel " \
   2820                  "for the connection: %s\n"),
   2821               MHD_itc_last_strerror_ ());
   2822 #endif
   2823     MHD_socket_close_chk_ (client_socket);
   2824     MHD_ip_limit_del (daemon,
   2825                       addr,
   2826                       addrlen);
   2827     if (NULL != connection->addr)
   2828       free (connection->addr);
   2829     free (connection);
   2830     errno = eno;
   2831     return NULL;
   2832   }
   2833 
   2834   if (0 == (daemon->options & MHD_USE_TLS))
   2835   {
   2836     /* set default connection handlers  */
   2837     MHD_set_http_callbacks_ (connection);
   2838   }
   2839   else
   2840   {
   2841 #ifdef HTTPS_SUPPORT
   2842 #if (GNUTLS_VERSION_NUMBER + 0 >= 0x030500)
   2843     gnutls_init_flags_t
   2844 #else
   2845     unsigned int
   2846 #endif
   2847     flags;
   2848 
   2849     flags = GNUTLS_SERVER;
   2850 #if (GNUTLS_VERSION_NUMBER + 0 >= 0x030402)
   2851     flags |= GNUTLS_NO_SIGNAL;
   2852 #endif /* GNUTLS_VERSION_NUMBER >= 0x030402 */
   2853 #if GNUTLS_VERSION_MAJOR >= 3
   2854     flags |= GNUTLS_NONBLOCK;
   2855 #endif /* GNUTLS_VERSION_MAJOR >= 3*/
   2856 #if (GNUTLS_VERSION_NUMBER + 0 >= 0x030603)
   2857     if (0 != (daemon->options & MHD_USE_POST_HANDSHAKE_AUTH_SUPPORT))
   2858       flags |= GNUTLS_POST_HANDSHAKE_AUTH;
   2859 #endif
   2860 #if (GNUTLS_VERSION_NUMBER + 0 >= 0x030605)
   2861     if (0 != (daemon->options & MHD_USE_INSECURE_TLS_EARLY_DATA))
   2862       flags |= GNUTLS_ENABLE_EARLY_DATA;
   2863 #endif
   2864     connection->tls_state = MHD_TLS_CONN_INIT;
   2865     MHD_set_https_callbacks (connection);
   2866     if ((GNUTLS_E_SUCCESS != gnutls_init (&connection->tls_session, flags)) ||
   2867         (GNUTLS_E_SUCCESS != gnutls_priority_set (connection->tls_session,
   2868                                                   daemon->priority_cache)))
   2869     {
   2870       if (NULL != connection->tls_session)
   2871         gnutls_deinit (connection->tls_session);
   2872       MHD_socket_close_chk_ (client_socket);
   2873       MHD_ip_limit_del (daemon,
   2874                         addr,
   2875                         addrlen);
   2876       if (NULL != connection->addr)
   2877         free (connection->addr);
   2878       free (connection);
   2879 #ifdef HAVE_MESSAGES
   2880       MHD_DLOG (daemon,
   2881                 _ ("Failed to initialise TLS session.\n"));
   2882 #endif
   2883 #if defined(EPROTO) && (EPROTO + 0 != 0)
   2884       errno = EPROTO;
   2885 #endif
   2886       return NULL;
   2887     }
   2888 #if (GNUTLS_VERSION_NUMBER + 0 >= 0x030200)
   2889     if (! daemon->disable_alpn)
   2890     {
   2891       static const char prt1[] = "http/1.1"; /* Registered code for HTTP/1.1 */
   2892       static const char prt2[] = "http/1.0"; /* Registered code for HTTP/1.0 */
   2893       static const gnutls_datum_t prts[2] =
   2894       { {_MHD_DROP_CONST (prt1), MHD_STATICSTR_LEN_ (prt1)},
   2895         {_MHD_DROP_CONST (prt2), MHD_STATICSTR_LEN_ (prt2)} };
   2896 
   2897       if (GNUTLS_E_SUCCESS !=
   2898           gnutls_alpn_set_protocols (connection->tls_session,
   2899                                      prts,
   2900                                      sizeof(prts) / sizeof(prts[0]),
   2901                                      0 /* | GNUTLS_ALPN_SERVER_PRECEDENCE */))
   2902       {
   2903 #ifdef HAVE_MESSAGES
   2904         MHD_DLOG (daemon,
   2905                   _ ("Failed to set ALPN protocols.\n"));
   2906 #else  /* ! HAVE_MESSAGES */
   2907         (void) 0; /* Mute compiler warning */
   2908 #endif /* ! HAVE_MESSAGES */
   2909       }
   2910     }
   2911 #endif /* GNUTLS_VERSION_NUMBER >= 0x030200 */
   2912     gnutls_session_set_ptr (connection->tls_session,
   2913                             connection);
   2914     switch (daemon->cred_type)
   2915     {
   2916     /* set needed credentials for certificate authentication. */
   2917     case GNUTLS_CRD_CERTIFICATE:
   2918       gnutls_credentials_set (connection->tls_session,
   2919                               GNUTLS_CRD_CERTIFICATE,
   2920                               daemon->x509_cred);
   2921       break;
   2922     case GNUTLS_CRD_PSK:
   2923       gnutls_credentials_set (connection->tls_session,
   2924                               GNUTLS_CRD_PSK,
   2925                               daemon->psk_cred);
   2926       gnutls_psk_set_server_credentials_function (daemon->psk_cred,
   2927                                                   &psk_gnutls_adapter);
   2928       break;
   2929     case GNUTLS_CRD_ANON:
   2930     case GNUTLS_CRD_SRP:
   2931     case GNUTLS_CRD_IA:
   2932     default:
   2933 #ifdef HAVE_MESSAGES
   2934       MHD_DLOG (daemon,
   2935                 _ ("Failed to setup TLS credentials: " \
   2936                    "unknown credential type %d.\n"),
   2937                 daemon->cred_type);
   2938 #endif
   2939       gnutls_deinit (connection->tls_session);
   2940       MHD_socket_close_chk_ (client_socket);
   2941       MHD_ip_limit_del (daemon,
   2942                         addr,
   2943                         addrlen);
   2944       if (NULL != connection->addr)
   2945         free (connection->addr);
   2946       free (connection);
   2947       MHD_PANIC (_ ("Unknown credential type.\n"));
   2948 #if defined(EINVAL) && (EINVAL + 0 != 0)
   2949       errno = EINVAL;
   2950 #endif
   2951       return NULL;
   2952     }
   2953 #if (GNUTLS_VERSION_NUMBER + 0 >= 0x030109) && ! defined(_WIN64)
   2954     gnutls_transport_set_int (connection->tls_session,
   2955                               (int) (client_socket));
   2956 #else  /* GnuTLS before 3.1.9 or Win x64 */
   2957     gnutls_transport_set_ptr (connection->tls_session,
   2958                               (gnutls_transport_ptr_t) \
   2959                               (intptr_t) client_socket);
   2960 #endif /* GnuTLS before 3.1.9 or Win x64 */
   2961 #ifdef MHD_TLSLIB_NEED_PUSH_FUNC
   2962     gnutls_transport_set_push_function (connection->tls_session,
   2963                                         MHD_tls_push_func_);
   2964 #endif /* MHD_TLSLIB_NEED_PUSH_FUNC */
   2965     if (daemon->https_mem_trust)
   2966       gnutls_certificate_server_set_request (connection->tls_session,
   2967                                              GNUTLS_CERT_REQUEST);
   2968 #else  /* ! HTTPS_SUPPORT */
   2969     MHD_socket_close_chk_ (client_socket);
   2970     MHD_ip_limit_del (daemon,
   2971                       addr,
   2972                       addrlen);
   2973     free (connection->addr);
   2974     free (connection);
   2975     MHD_PANIC (_ ("TLS connection on non-TLS daemon.\n"));
   2976 #if 0
   2977     /* Unreachable code */
   2978     eno = EINVAL;
   2979     return NULL;
   2980 #endif
   2981 #endif /* ! HTTPS_SUPPORT */
   2982   }
   2983 
   2984   return connection;
   2985 }
   2986 
   2987 
   2988 #ifdef MHD_USE_THREADS
   2989 /**
   2990  * Close prepared, but not yet processed connection.
   2991  * @param daemon     the daemon
   2992  * @param connection the connection to close
   2993  */
   2994 static void
   2995 new_connection_close_ (struct MHD_Daemon *daemon,
   2996                        struct MHD_Connection *connection)
   2997 {
   2998   mhd_assert (connection->daemon == daemon);
   2999   mhd_assert (! connection->in_cleanup);
   3000   mhd_assert (NULL == connection->next);
   3001   mhd_assert (NULL == connection->nextX);
   3002 #ifdef EPOLL_SUPPORT
   3003   mhd_assert (NULL == connection->nextE);
   3004 #endif /* EPOLL_SUPPORT */
   3005 
   3006 #ifdef HTTPS_SUPPORT
   3007   if (NULL != connection->tls_session)
   3008   {
   3009     mhd_assert (0 != (daemon->options & MHD_USE_TLS));
   3010     gnutls_deinit (connection->tls_session);
   3011   }
   3012 #endif /* HTTPS_SUPPORT */
   3013   MHD_socket_close_chk_ (connection->socket_fd);
   3014   if (MHD_ITC_IS_VALID_ (connection->resume_itc))
   3015     MHD_itc_destroy_chk_ (connection->resume_itc);
   3016   MHD_ip_limit_del (daemon,
   3017                     connection->addr,
   3018                     connection->addr_len);
   3019   if (NULL != connection->addr)
   3020     free (connection->addr);
   3021   free (connection);
   3022 }
   3023 
   3024 
   3025 #endif /* MHD_USE_THREADS */
   3026 
   3027 
   3028 /**
   3029  * Finally insert the new connection to the list of connections
   3030  * served by the daemon and start processing.
   3031  * @remark To be called only from thread that process
   3032  * daemon's select()/poll()/etc.
   3033  *
   3034  * @param daemon daemon that manages the connection
   3035  * @param connection the newly created connection
   3036  * @return #MHD_YES on success, #MHD_NO on error
   3037  */
   3038 static enum MHD_Result
   3039 new_connection_process_ (struct MHD_Daemon *daemon,
   3040                          struct MHD_Connection *connection)
   3041 {
   3042   int eno = 0;
   3043 
   3044   mhd_assert (connection->daemon == daemon);
   3045 
   3046 #ifdef MHD_USE_THREADS
   3047   /* Function manipulate connection and timeout DL-lists,
   3048    * must be called only within daemon thread. */
   3049   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   3050                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   3051   mhd_assert (NULL == daemon->worker_pool);
   3052 #endif /* MHD_USE_THREADS */
   3053 
   3054   /* Allocate memory pool in the processing thread so
   3055    * intensively used memory area is allocated in "good"
   3056    * (for the thread) memory region. It is important with
   3057    * NUMA and/or complex cache hierarchy. */
   3058   connection->pool = MHD_pool_create (daemon->pool_size);
   3059   if (NULL == connection->pool)
   3060   { /* 'pool' creation failed */
   3061 #ifdef HAVE_MESSAGES
   3062     MHD_DLOG (daemon,
   3063               _ ("Error allocating memory: %s\n"),
   3064               MHD_strerror_ (errno));
   3065 #endif
   3066 #if defined(ENOMEM) && (ENOMEM + 0 != 0)
   3067     eno = ENOMEM;
   3068 #endif
   3069     (void) 0; /* Mute possible compiler warning */
   3070   }
   3071   else
   3072   { /* 'pool' creation succeed */
   3073     MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   3074     /* Firm check under lock. */
   3075     if (daemon->connections >= daemon->connection_limit)
   3076     { /* Connections limit */
   3077       MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3078 #ifdef HAVE_MESSAGES
   3079       MHD_DLOG (daemon,
   3080                 _ ("Server reached connection limit. "
   3081                    "Closing inbound connection.\n"));
   3082 #endif
   3083 #if defined(ENFILE) && (ENFILE + 0 != 0)
   3084       eno = ENFILE;
   3085 #endif
   3086       (void) 0; /* Mute possible compiler warning */
   3087     }
   3088     else
   3089     { /* Have space for new connection */
   3090       daemon->connections++;
   3091       DLL_insert (daemon->connections_head,
   3092                   daemon->connections_tail,
   3093                   connection);
   3094       if (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   3095       {
   3096         XDLL_insert (daemon->normal_timeout_head,
   3097                      daemon->normal_timeout_tail,
   3098                      connection);
   3099       }
   3100       MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3101 
   3102       MHD_connection_set_initial_state_ (connection);
   3103 
   3104       if (NULL != daemon->notify_connection)
   3105         daemon->notify_connection (daemon->notify_connection_cls,
   3106                                    connection,
   3107                                    &connection->socket_context,
   3108                                    MHD_CONNECTION_NOTIFY_STARTED);
   3109 #ifdef MHD_USE_THREADS
   3110       if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   3111       {
   3112         mhd_assert (! MHD_D_IS_USING_EPOLL_ (daemon));
   3113         if (! MHD_create_named_thread_ (&connection->tid,
   3114                                         "MHD-connection",
   3115                                         daemon->thread_stack_size,
   3116                                         &thread_main_handle_connection,
   3117                                         connection))
   3118         {
   3119           eno = errno;
   3120 #ifdef HAVE_MESSAGES
   3121 #ifdef EAGAIN
   3122           if (EAGAIN == eno)
   3123             MHD_DLOG (daemon,
   3124                       _ ("Failed to create a new thread because it would "
   3125                          "have exceeded the system limit on the number of "
   3126                          "threads or no system resources available.\n"));
   3127           else
   3128 #endif /* EAGAIN */
   3129           MHD_DLOG (daemon,
   3130                     _ ("Failed to create a thread: %s\n"),
   3131                     MHD_strerror_ (eno));
   3132 #endif /* HAVE_MESSAGES */
   3133         }
   3134         else               /* New thread has been created successfully */
   3135           return MHD_YES;  /* *** Function success exit point *** */
   3136       }
   3137       else
   3138 #else  /* ! MHD_USE_THREADS */
   3139       if (1)
   3140 #endif /* ! MHD_USE_THREADS */
   3141       { /* No 'thread-per-connection' */
   3142 #ifdef MHD_USE_THREADS
   3143         connection->tid = daemon->tid;
   3144 #endif /* MHD_USE_THREADS */
   3145 #ifdef EPOLL_SUPPORT
   3146         if (MHD_D_IS_USING_EPOLL_ (daemon))
   3147         {
   3148           if (0 == (daemon->options & MHD_USE_TURBO))
   3149           {
   3150             struct epoll_event event;
   3151 
   3152             event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET | EPOLLRDHUP;
   3153             event.data.ptr = connection;
   3154             if (0 != epoll_ctl (daemon->epoll_fd,
   3155                                 EPOLL_CTL_ADD,
   3156                                 connection->socket_fd,
   3157                                 &event))
   3158             {
   3159               eno = errno;
   3160 #ifdef HAVE_MESSAGES
   3161               MHD_DLOG (daemon,
   3162                         _ ("Call to epoll_ctl failed: %s\n"),
   3163                         MHD_socket_last_strerr_ ());
   3164 #endif
   3165             }
   3166             else
   3167             { /* 'socket_fd' has been added to 'epool' */
   3168               connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
   3169 
   3170               return MHD_YES;  /* *** Function success exit point *** */
   3171             }
   3172           }
   3173           else
   3174           {
   3175             connection->epoll_state |= MHD_EPOLL_STATE_READ_READY
   3176                                        | MHD_EPOLL_STATE_WRITE_READY
   3177                                        | MHD_EPOLL_STATE_IN_EREADY_EDLL;
   3178             EDLL_insert (daemon->eready_head,
   3179                          daemon->eready_tail,
   3180                          connection);
   3181 
   3182             return MHD_YES;  /* *** Function success exit point *** */
   3183           }
   3184         }
   3185         else /* No 'epoll' */
   3186 #endif /* EPOLL_SUPPORT */
   3187         return MHD_YES;    /* *** Function success exit point *** */
   3188       }
   3189 
   3190       /* ** Below is a cleanup path ** */
   3191       if (NULL != daemon->notify_connection)
   3192         daemon->notify_connection (daemon->notify_connection_cls,
   3193                                    connection,
   3194                                    &connection->socket_context,
   3195                                    MHD_CONNECTION_NOTIFY_CLOSED);
   3196       MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   3197       if (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   3198       {
   3199         XDLL_remove (daemon->normal_timeout_head,
   3200                      daemon->normal_timeout_tail,
   3201                      connection);
   3202       }
   3203       DLL_remove (daemon->connections_head,
   3204                   daemon->connections_tail,
   3205                   connection);
   3206       daemon->connections--;
   3207       MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3208     }
   3209     MHD_pool_destroy (connection->pool);
   3210   }
   3211   /* Free resources allocated before the call of this functions */
   3212 #ifdef HTTPS_SUPPORT
   3213   if (NULL != connection->tls_session)
   3214     gnutls_deinit (connection->tls_session);
   3215 #endif /* HTTPS_SUPPORT */
   3216   MHD_ip_limit_del (daemon,
   3217                     connection->addr,
   3218                     connection->addr_len);
   3219   if (NULL != connection->addr)
   3220     free (connection->addr);
   3221   MHD_socket_close_chk_ (connection->socket_fd);
   3222   free (connection);
   3223   if (0 != eno)
   3224     errno = eno;
   3225 #ifdef EINVAL
   3226   else
   3227     errno = EINVAL;
   3228 #endif /* EINVAL */
   3229   return MHD_NO;  /* *** Function failure exit point *** */
   3230 }
   3231 
   3232 
   3233 /**
   3234  * Add another client connection to the set of connections
   3235  * managed by MHD.  This API is usually not needed (since
   3236  * MHD will accept inbound connections on the server socket).
   3237  * Use this API in special cases, for example if your HTTP
   3238  * server is behind NAT and needs to connect out to the
   3239  * HTTP client.
   3240  *
   3241  * The given client socket will be managed (and closed!) by MHD after
   3242  * this call and must no longer be used directly by the application
   3243  * afterwards.
   3244  *
   3245  * @param daemon daemon that manages the connection
   3246  * @param client_socket socket to manage (MHD will expect
   3247  *        to receive an HTTP request from this socket next).
   3248  * @param addr IP address of the client
   3249  * @param addrlen number of bytes in @a addr
   3250  * @param external_add perform additional operations needed due
   3251  *        to the application calling us directly
   3252  * @param non_blck indicate that socket in non-blocking mode
   3253  * @param sk_spipe_supprs indicate that the @a client_socket has
   3254  *                         set SIGPIPE suppression
   3255  * @param sk_is_nonip _MHD_YES if this is not a TCP/IP socket
   3256  * @return #MHD_YES on success, #MHD_NO if this daemon could
   3257  *        not handle the connection (i.e. malloc failed, etc).
   3258  *        The socket will be closed in any case; 'errno' is
   3259  *        set to indicate further details about the error.
   3260  */
   3261 static enum MHD_Result
   3262 internal_add_connection (struct MHD_Daemon *daemon,
   3263                          MHD_socket client_socket,
   3264                          const struct sockaddr_storage *addr,
   3265                          socklen_t addrlen,
   3266                          bool external_add,
   3267                          bool non_blck,
   3268                          bool sk_spipe_supprs,
   3269                          enum MHD_tristate sk_is_nonip)
   3270 {
   3271   struct MHD_Connection *connection;
   3272 
   3273 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3274   /* Direct add to master daemon could never happen. */
   3275   mhd_assert (NULL == daemon->worker_pool);
   3276 #endif
   3277 
   3278   if (MHD_D_IS_USING_SELECT_ (daemon) &&
   3279       (! MHD_D_DOES_SCKT_FIT_FDSET_ (client_socket, daemon)) )
   3280   {
   3281 #ifdef HAVE_MESSAGES
   3282     MHD_DLOG (daemon,
   3283               _ ("New connection socket descriptor (%d) is not less " \
   3284                  "than FD_SETSIZE (%d).\n"),
   3285               (int) client_socket,
   3286               (int) MHD_D_GET_FD_SETSIZE_ (daemon));
   3287 #endif
   3288     MHD_socket_close_chk_ (client_socket);
   3289 #if defined(ENFILE) && (ENFILE + 0 != 0)
   3290     errno = ENFILE;
   3291 #endif
   3292     return MHD_NO;
   3293   }
   3294 
   3295   if (MHD_D_IS_USING_EPOLL_ (daemon) &&
   3296       (! non_blck) )
   3297   {
   3298 #ifdef HAVE_MESSAGES
   3299     MHD_DLOG (daemon,
   3300               _ ("Epoll mode supports only non-blocking sockets\n"));
   3301 #endif
   3302     MHD_socket_close_chk_ (client_socket);
   3303 #if defined(EINVAL) && (EINVAL + 0 != 0)
   3304     errno = EINVAL;
   3305 #endif
   3306     return MHD_NO;
   3307   }
   3308 
   3309   connection = new_connection_prepare_ (daemon,
   3310                                         client_socket,
   3311                                         addr, addrlen,
   3312                                         external_add,
   3313                                         non_blck,
   3314                                         sk_spipe_supprs,
   3315                                         sk_is_nonip);
   3316   if (NULL == connection)
   3317     return MHD_NO;
   3318 
   3319   if ((external_add) &&
   3320       MHD_D_IS_THREAD_SAFE_ (daemon))
   3321   {
   3322     /* Connection is added externally and MHD is thread safe mode. */
   3323     MHD_mutex_lock_chk_ (&daemon->new_connections_mutex);
   3324     DLL_insert (daemon->new_connections_head,
   3325                 daemon->new_connections_tail,
   3326                 connection);
   3327     daemon->have_new = true;
   3328     MHD_mutex_unlock_chk_ (&daemon->new_connections_mutex);
   3329 
   3330     /* The rest of connection processing must be handled in
   3331      * the daemon thread. */
   3332     if ((MHD_ITC_IS_VALID_ (daemon->itc)) &&
   3333         (! MHD_itc_activate_ (daemon->itc, "n")))
   3334     {
   3335 #ifdef HAVE_MESSAGES
   3336       MHD_DLOG (daemon,
   3337                 _ ("Failed to signal new connection via inter-thread " \
   3338                    "communication channel.\n"));
   3339 #endif
   3340     }
   3341     return MHD_YES;
   3342   }
   3343 
   3344   return new_connection_process_ (daemon, connection);
   3345 }
   3346 
   3347 
   3348 static void
   3349 new_connections_list_process_ (struct MHD_Daemon *daemon)
   3350 {
   3351   struct MHD_Connection *local_head;
   3352   struct MHD_Connection *local_tail;
   3353   mhd_assert (daemon->have_new);
   3354   mhd_assert (MHD_D_IS_THREAD_SAFE_ (daemon));
   3355 
   3356   /* Detach DL-list of new connections from the daemon for
   3357    * following local processing. */
   3358   MHD_mutex_lock_chk_ (&daemon->new_connections_mutex);
   3359   mhd_assert (NULL != daemon->new_connections_head);
   3360   local_head = daemon->new_connections_head;
   3361   local_tail = daemon->new_connections_tail;
   3362   daemon->new_connections_head = NULL;
   3363   daemon->new_connections_tail = NULL;
   3364   daemon->have_new = false;
   3365   MHD_mutex_unlock_chk_ (&daemon->new_connections_mutex);
   3366   (void) local_head; /* Mute compiler warning */
   3367 
   3368   /* Process new connections in FIFO order. */
   3369   do
   3370   {
   3371     struct MHD_Connection *c;   /**< Currently processed connection */
   3372 
   3373     c = local_tail;
   3374     DLL_remove (local_head,
   3375                 local_tail,
   3376                 c);
   3377     mhd_assert (daemon == c->daemon);
   3378     if (MHD_NO == new_connection_process_ (daemon, c))
   3379     {
   3380 #ifdef HAVE_MESSAGES
   3381       MHD_DLOG (daemon,
   3382                 _ ("Failed to start serving new connection.\n"));
   3383 #endif
   3384       (void) 0;
   3385     }
   3386   } while (NULL != local_tail);
   3387 
   3388 }
   3389 
   3390 
   3391 /**
   3392  * Internal version of ::MHD_suspend_connection().
   3393  *
   3394  * @remark In thread-per-connection mode: can be called from any thread,
   3395  * in any other mode: to be called only from thread that process
   3396  * daemon's select()/poll()/etc.
   3397  *
   3398  * @param connection the connection to suspend
   3399  */
   3400 void
   3401 internal_suspend_connection_ (struct MHD_Connection *connection)
   3402 {
   3403   struct MHD_Daemon *daemon = connection->daemon;
   3404   mhd_assert (NULL == daemon->worker_pool);
   3405 
   3406 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3407   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   3408                MHD_D_IS_USING_THREAD_PER_CONN_ (daemon) || \
   3409                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   3410   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   3411 #endif
   3412   if (connection->resuming)
   3413   {
   3414     /* suspending again while we didn't even complete resuming yet */
   3415     connection->resuming = false;
   3416 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3417     MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3418 #endif
   3419     return;
   3420   }
   3421   if (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   3422   {
   3423     if (connection->connection_timeout_ms == daemon->connection_timeout_ms)
   3424       XDLL_remove (daemon->normal_timeout_head,
   3425                    daemon->normal_timeout_tail,
   3426                    connection);
   3427     else
   3428       XDLL_remove (daemon->manual_timeout_head,
   3429                    daemon->manual_timeout_tail,
   3430                    connection);
   3431   }
   3432   DLL_remove (daemon->connections_head,
   3433               daemon->connections_tail,
   3434               connection);
   3435   mhd_assert (! connection->suspended);
   3436   DLL_insert (daemon->suspended_connections_head,
   3437               daemon->suspended_connections_tail,
   3438               connection);
   3439   connection->suspended = true;
   3440 #ifdef EPOLL_SUPPORT
   3441   if (MHD_D_IS_USING_EPOLL_ (daemon))
   3442   {
   3443     if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
   3444     {
   3445       EDLL_remove (daemon->eready_head,
   3446                    daemon->eready_tail,
   3447                    connection);
   3448       connection->epoll_state &=
   3449         ~((enum MHD_EpollState) MHD_EPOLL_STATE_IN_EREADY_EDLL);
   3450     }
   3451     if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET))
   3452     {
   3453       if (0 != epoll_ctl (daemon->epoll_fd,
   3454                           EPOLL_CTL_DEL,
   3455                           connection->socket_fd,
   3456                           NULL))
   3457         MHD_PANIC (_ ("Failed to remove FD from epoll set.\n"));
   3458       connection->epoll_state &=
   3459         ~((enum MHD_EpollState) MHD_EPOLL_STATE_IN_EPOLL_SET);
   3460     }
   3461     connection->epoll_state |= MHD_EPOLL_STATE_SUSPENDED;
   3462   }
   3463 #endif
   3464 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3465   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3466 #endif
   3467 }
   3468 
   3469 
   3470 /**
   3471  * Suspend handling of network data for a given connection.
   3472  * This can be used to dequeue a connection from MHD's event loop
   3473  * (not applicable to thread-per-connection!) for a while.
   3474  *
   3475  * If you use this API in conjunction with an "internal" socket polling,
   3476  * you must set the option #MHD_USE_ITC to ensure that a resumed
   3477  * connection is immediately processed by MHD.
   3478  *
   3479  * Suspended connections continue to count against the total number of
   3480  * connections allowed (per daemon, as well as per IP, if such limits
   3481  * are set).  Suspended connections will NOT time out; timeouts will
   3482  * restart when the connection handling is resumed.  While a
   3483  * connection is suspended, MHD will not detect disconnects by the
   3484  * client.
   3485  *
   3486  * The only safe way to call this function is to call it from the
   3487  * #MHD_AccessHandlerCallback or #MHD_ContentReaderCallback.
   3488  *
   3489  * Finally, it is an API violation to call #MHD_stop_daemon while
   3490  * having suspended connections (this will at least create memory and
   3491  * socket leaks or lead to undefined behavior).  You must explicitly
   3492  * resume all connections before stopping the daemon.
   3493  *
   3494  * @param connection the connection to suspend
   3495  *
   3496  * @sa #MHD_AccessHandlerCallback
   3497  */
   3498 _MHD_EXTERN void
   3499 MHD_suspend_connection (struct MHD_Connection *connection)
   3500 {
   3501   struct MHD_Daemon *const daemon = connection->daemon;
   3502 
   3503 #ifdef MHD_USE_THREADS
   3504   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   3505                MHD_D_IS_USING_THREAD_PER_CONN_ (daemon) || \
   3506                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   3507 #endif /* MHD_USE_THREADS */
   3508 
   3509   if (0 == (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME))
   3510     MHD_PANIC (_ ("Cannot suspend connections without " \
   3511                   "enabling MHD_ALLOW_SUSPEND_RESUME!\n"));
   3512 #ifdef UPGRADE_SUPPORT
   3513   if (NULL != connection->urh)
   3514   {
   3515 #ifdef HAVE_MESSAGES
   3516     MHD_DLOG (daemon,
   3517               _ ("Error: connection scheduled for \"upgrade\" cannot " \
   3518                  "be suspended.\n"));
   3519 #endif /* HAVE_MESSAGES */
   3520     return;
   3521   }
   3522 #endif /* UPGRADE_SUPPORT */
   3523   internal_suspend_connection_ (connection);
   3524 }
   3525 
   3526 
   3527 /**
   3528  * Resume handling of network data for suspended connection.  It is
   3529  * safe to resume a suspended connection at any time.  Calling this
   3530  * function on a connection that was not previously suspended will
   3531  * result in undefined behavior.
   3532  *
   3533  * If you are using this function in "external" sockets polling mode, you must
   3534  * make sure to run #MHD_run() and #MHD_get_timeout() afterwards (before
   3535  * again calling #MHD_get_fdset()), as otherwise the change may not be
   3536  * reflected in the set returned by #MHD_get_fdset() and you may end up
   3537  * with a connection that is stuck until the next network activity.
   3538  *
   3539  * @param connection the connection to resume
   3540  */
   3541 _MHD_EXTERN void
   3542 MHD_resume_connection (struct MHD_Connection *connection)
   3543 {
   3544   struct MHD_Daemon *daemon = connection->daemon;
   3545   bool own_thread; /**< The connection's own thread completes the resume */
   3546 #if defined(MHD_USE_THREADS)
   3547   mhd_assert (NULL == daemon->worker_pool);
   3548 #endif /* MHD_USE_THREADS */
   3549 
   3550   if (0 == (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME))
   3551     MHD_PANIC (_ ("Cannot resume connections without enabling " \
   3552                   "MHD_ALLOW_SUSPEND_RESUME!\n"));
   3553 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3554   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   3555 #endif
   3556   connection->resuming = true;
   3557   /* An "upgraded" connection is resumed only to be moved to the cleanup
   3558      list, which is the daemon thread's job even with a thread per
   3559      connection. */
   3560   own_thread = MHD_D_IS_USING_THREAD_PER_CONN_ (daemon)
   3561 #ifdef UPGRADE_SUPPORT
   3562                && (NULL == connection->urh)
   3563 #endif /* UPGRADE_SUPPORT */
   3564   ;
   3565   if (! own_thread)
   3566     daemon->resuming = true;
   3567 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3568   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3569 #endif
   3570   if (own_thread)
   3571   {
   3572     /* Wake the connection's own thread.  See the description of
   3573        @e resume_itc for why the daemon-wide ITC will not do. */
   3574     mhd_assert (MHD_ITC_IS_VALID_ (connection->resume_itc));
   3575     if (! MHD_itc_activate_ (connection->resume_itc, "r"))
   3576     {
   3577 #ifdef HAVE_MESSAGES
   3578       MHD_DLOG (daemon,
   3579                 _ ("Failed to signal resume via the connection's " \
   3580                    "inter-thread communication channel.\n"));
   3581 #endif
   3582     }
   3583   }
   3584   else if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
   3585             (! MHD_itc_activate_ (daemon->itc, "r")) )
   3586   {
   3587 #ifdef HAVE_MESSAGES
   3588     MHD_DLOG (daemon,
   3589               _ ("Failed to signal resume via inter-thread " \
   3590                  "communication channel.\n"));
   3591 #endif
   3592   }
   3593 }
   3594 
   3595 
   3596 #ifdef UPGRADE_SUPPORT
   3597 /**
   3598  * Mark upgraded connection as closed by application.
   3599  *
   3600  * The @a connection pointer must not be used after call of this function
   3601  * as it may be freed in other thread immediately.
   3602  * @param connection the upgraded connection to mark as closed by application
   3603  */
   3604 void
   3605 MHD_upgraded_connection_mark_app_closed_ (struct MHD_Connection *connection)
   3606 {
   3607   /* Cache 'daemon' here to avoid data races */
   3608   struct MHD_Daemon *const daemon = connection->daemon;
   3609 #if defined(MHD_USE_THREADS)
   3610   mhd_assert (NULL == daemon->worker_pool);
   3611 #endif /* MHD_USE_THREADS */
   3612   mhd_assert (NULL != connection->urh);
   3613   mhd_assert (0 != (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME));
   3614 
   3615   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   3616   connection->urh->was_closed = true;
   3617   connection->resuming = true;
   3618   daemon->resuming = true;
   3619   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3620   if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
   3621        (! MHD_itc_activate_ (daemon->itc, "r")) )
   3622   {
   3623 #ifdef HAVE_MESSAGES
   3624     MHD_DLOG (daemon,
   3625               _ ("Failed to signal resume via " \
   3626                  "inter-thread communication channel.\n"));
   3627 #endif
   3628   }
   3629 }
   3630 
   3631 
   3632 #endif /* UPGRADE_SUPPORT */
   3633 
   3634 /**
   3635  * Run through the suspended connections and move any that are no
   3636  * longer suspended back to the active state.
   3637  * @remark To be called only from thread that process
   3638  * daemon's select()/poll()/etc.
   3639  *
   3640  * @param daemon daemon context
   3641  * @return #MHD_YES if a connection was actually resumed
   3642  */
   3643 static enum MHD_Result
   3644 resume_suspended_connections (struct MHD_Daemon *daemon)
   3645 {
   3646   struct MHD_Connection *pos;
   3647   struct MHD_Connection *prev = NULL;
   3648   enum MHD_Result ret;
   3649   const bool used_thr_p_c = (0 != (daemon->options
   3650                                    & MHD_USE_THREAD_PER_CONNECTION));
   3651 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3652   mhd_assert (NULL == daemon->worker_pool);
   3653   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   3654                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   3655 #endif
   3656 
   3657   ret = MHD_NO;
   3658 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3659   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   3660 #endif
   3661 
   3662   if (daemon->resuming)
   3663   {
   3664     prev = daemon->suspended_connections_tail;
   3665     /* During shutdown check for resuming is forced. */
   3666     mhd_assert ((NULL != prev) || (daemon->shutdown) || \
   3667                 (0 != (daemon->options & MHD_ALLOW_UPGRADE)));
   3668   }
   3669 
   3670   daemon->resuming = false;
   3671 
   3672   while (NULL != (pos = prev))
   3673   {
   3674 #ifdef UPGRADE_SUPPORT
   3675     struct MHD_UpgradeResponseHandle *const urh = pos->urh;
   3676 #else  /* ! UPGRADE_SUPPORT */
   3677     static const void *const urh = NULL;
   3678 #endif /* ! UPGRADE_SUPPORT */
   3679     prev = pos->prev;
   3680     if ( (! pos->resuming)
   3681 #ifdef UPGRADE_SUPPORT
   3682          || ( (NULL != urh) &&
   3683               ( (! urh->was_closed) ||
   3684                 (! urh->clean_ready) ) )
   3685 #endif /* UPGRADE_SUPPORT */
   3686          )
   3687       continue;
   3688     ret = MHD_YES;
   3689     mhd_assert (pos->suspended);
   3690     DLL_remove (daemon->suspended_connections_head,
   3691                 daemon->suspended_connections_tail,
   3692                 pos);
   3693     pos->suspended = false;
   3694     if (NULL == urh)
   3695     {
   3696       DLL_insert (daemon->connections_head,
   3697                   daemon->connections_tail,
   3698                   pos);
   3699       if (! used_thr_p_c)
   3700       {
   3701         /* The states of a suspended connection are not updated, so they
   3702            are stale now that it is running again.  Updating them here
   3703            would mean running the state machine under the cleanup mutex,
   3704            which is what 0ecf4f26e4c1a4c03d66e1d04bf4cae62bd236a0 backed
   3705            out of; flag the connection instead and let call_handlers()
   3706            update it before it acts on @e event_loop_info.  Thread-per-
   3707            connection does the same for itself, in
   3708            thread_main_handle_connection(). */
   3709         pos->resumed = true;
   3710 
   3711         /* Reset timeout timer on resume. */
   3712         if (0 != pos->connection_timeout_ms)
   3713           pos->last_activity = MHD_monotonic_msec_counter ();
   3714 
   3715         if (pos->connection_timeout_ms == daemon->connection_timeout_ms)
   3716           XDLL_insert (daemon->normal_timeout_head,
   3717                        daemon->normal_timeout_tail,
   3718                        pos);
   3719         else
   3720           XDLL_insert (daemon->manual_timeout_head,
   3721                        daemon->manual_timeout_tail,
   3722                        pos);
   3723       }
   3724 #ifdef EPOLL_SUPPORT
   3725       if (MHD_D_IS_USING_EPOLL_ (daemon))
   3726       {
   3727         if (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
   3728           MHD_PANIC ("Resumed connection was already in EREADY set.\n");
   3729         /* we always mark resumed connections as ready, as we
   3730            might have missed the edge poll event during suspension */
   3731         EDLL_insert (daemon->eready_head,
   3732                      daemon->eready_tail,
   3733                      pos);
   3734         pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL   \
   3735                             | MHD_EPOLL_STATE_READ_READY
   3736                             | MHD_EPOLL_STATE_WRITE_READY;
   3737         pos->epoll_state &= ~((enum MHD_EpollState) MHD_EPOLL_STATE_SUSPENDED);
   3738       }
   3739 #endif
   3740     }
   3741 #ifdef UPGRADE_SUPPORT
   3742     else
   3743     {
   3744       /* Data forwarding was finished (for TLS connections) AND
   3745        * application was closed upgraded connection.
   3746        * Insert connection into cleanup list. */
   3747       if ( (NULL != daemon->notify_completed) &&
   3748            (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon)) &&
   3749            (pos->rq.client_aware) )
   3750       {
   3751         daemon->notify_completed (daemon->notify_completed_cls,
   3752                                   pos,
   3753                                   &pos->rq.client_context,
   3754                                   MHD_REQUEST_TERMINATED_COMPLETED_OK);
   3755         pos->rq.client_aware = false;
   3756       }
   3757       DLL_insert (daemon->cleanup_head,
   3758                   daemon->cleanup_tail,
   3759                   pos);
   3760       daemon->data_already_pending = true;
   3761     }
   3762 #endif /* UPGRADE_SUPPORT */
   3763     pos->resuming = false;
   3764   }
   3765 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3766   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   3767 #endif
   3768   if ( (used_thr_p_c) &&
   3769        (MHD_NO != ret) )
   3770   {   /* Wake up suspended connections. */
   3771     if (! MHD_itc_activate_ (daemon->itc,
   3772                              "w"))
   3773     {
   3774 #ifdef HAVE_MESSAGES
   3775       MHD_DLOG (daemon,
   3776                 _ ("Failed to signal resume of connection via " \
   3777                    "inter-thread communication channel.\n"));
   3778 #endif
   3779     }
   3780   }
   3781   return ret;
   3782 }
   3783 
   3784 
   3785 /**
   3786  * Add another client connection to the set of connections managed by
   3787  * MHD.  This API is usually not needed (since MHD will accept inbound
   3788  * connections on the server socket).  Use this API in special cases,
   3789  * for example if your HTTP server is behind NAT and needs to connect
   3790  * out to the HTTP client, or if you are building a proxy.
   3791  *
   3792  * If you use this API in conjunction with a internal select or a
   3793  * thread pool, you must set the option
   3794  * #MHD_USE_ITC to ensure that the freshly added
   3795  * connection is immediately processed by MHD.
   3796  *
   3797  * The given client socket will be managed (and closed!) by MHD after
   3798  * this call and must no longer be used directly by the application
   3799  * afterwards.
   3800  *
   3801  * @param daemon daemon that manages the connection
   3802  * @param client_socket socket to manage (MHD will expect
   3803  *        to receive an HTTP request from this socket next).
   3804  * @param addr IP address of the client
   3805  * @param addrlen number of bytes in @a addr
   3806  * @return #MHD_YES on success, #MHD_NO if this daemon could
   3807  *        not handle the connection (i.e. malloc() failed, etc).
   3808  *        The socket will be closed in any case; `errno` is
   3809  *        set to indicate further details about the error.
   3810  * @ingroup specialized
   3811  */
   3812 _MHD_EXTERN enum MHD_Result
   3813 MHD_add_connection (struct MHD_Daemon *daemon,
   3814                     MHD_socket client_socket,
   3815                     const struct sockaddr *addr,
   3816                     socklen_t addrlen)
   3817 {
   3818   bool sk_nonbl;
   3819   bool sk_spipe_supprs;
   3820   struct sockaddr_storage addrstorage;
   3821 
   3822   /* TODO: fix atomic value reading */
   3823   if ((! MHD_D_IS_THREAD_SAFE_ (daemon)) &&
   3824       (daemon->connection_limit <= daemon->connections))
   3825     MHD_cleanup_connections (daemon);
   3826 
   3827 #ifdef HAVE_MESSAGES
   3828   if (MHD_D_IS_USING_THREADS_ (daemon) &&
   3829       (0 == (daemon->options & MHD_USE_ITC)))
   3830   {
   3831     MHD_DLOG (daemon,
   3832               _ ("MHD_add_connection() has been called for daemon started"
   3833                  " without MHD_USE_ITC flag.\nDaemon will not process newly"
   3834                  " added connection until any activity occurs in already"
   3835                  " added sockets.\n"));
   3836   }
   3837 #endif /* HAVE_MESSAGES */
   3838   if (0 != addrlen)
   3839   {
   3840     if (AF_INET == addr->sa_family)
   3841     {
   3842       if (sizeof(struct sockaddr_in) > (size_t) addrlen)
   3843       {
   3844 #ifdef HAVE_MESSAGES
   3845         MHD_DLOG (daemon,
   3846                   _ ("MHD_add_connection() has been called with "
   3847                      "incorrect 'addrlen' value.\n"));
   3848 #endif /* HAVE_MESSAGES */
   3849         return MHD_NO;
   3850       }
   3851 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
   3852       if ((0 != addr->sa_len) &&
   3853           (sizeof(struct sockaddr_in) > (size_t) addr->sa_len) )
   3854       {
   3855 #ifdef HAVE_MESSAGES
   3856         MHD_DLOG (daemon,
   3857                   _ ("MHD_add_connection() has been called with " \
   3858                      "non-zero value of 'sa_len' member of " \
   3859                      "'struct sockaddr' which does not match 'sa_family'.\n"));
   3860 #endif /* HAVE_MESSAGES */
   3861         return MHD_NO;
   3862       }
   3863 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
   3864     }
   3865 #ifdef HAVE_INET6
   3866     if (AF_INET6 == addr->sa_family)
   3867     {
   3868       if (sizeof(struct sockaddr_in6) > (size_t) addrlen)
   3869       {
   3870 #ifdef HAVE_MESSAGES
   3871         MHD_DLOG (daemon,
   3872                   _ ("MHD_add_connection() has been called with "
   3873                      "incorrect 'addrlen' value.\n"));
   3874 #endif /* HAVE_MESSAGES */
   3875         return MHD_NO;
   3876       }
   3877 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
   3878       if ((0 != addr->sa_len) &&
   3879           (sizeof(struct sockaddr_in6) > (size_t) addr->sa_len) )
   3880       {
   3881 #ifdef HAVE_MESSAGES
   3882         MHD_DLOG (daemon,
   3883                   _ ("MHD_add_connection() has been called with " \
   3884                      "non-zero value of 'sa_len' member of " \
   3885                      "'struct sockaddr' which does not match 'sa_family'.\n"));
   3886 #endif /* HAVE_MESSAGES */
   3887         return MHD_NO;
   3888       }
   3889 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
   3890     }
   3891 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
   3892     if ((0 != addr->sa_len) &&
   3893         (addrlen > addr->sa_len))
   3894       addrlen = (socklen_t) addr->sa_len;   /* Use safest value */
   3895 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
   3896 #endif /* HAVE_INET6 */
   3897   }
   3898 
   3899   if (! MHD_socket_nonblocking_ (client_socket))
   3900   {
   3901 #ifdef HAVE_MESSAGES
   3902     MHD_DLOG (daemon,
   3903               _ ("Failed to set nonblocking mode on new client socket: %s\n"),
   3904               MHD_socket_last_strerr_ ());
   3905 #endif
   3906     sk_nonbl = false;
   3907   }
   3908   else
   3909     sk_nonbl = true;
   3910 
   3911 #ifndef MHD_WINSOCK_SOCKETS
   3912   sk_spipe_supprs = false;
   3913 #else  /* MHD_WINSOCK_SOCKETS */
   3914   sk_spipe_supprs = true; /* Nothing to suppress on W32 */
   3915 #endif /* MHD_WINSOCK_SOCKETS */
   3916 #if defined(MHD_socket_nosignal_)
   3917   if (! sk_spipe_supprs)
   3918     sk_spipe_supprs = MHD_socket_nosignal_ (client_socket);
   3919   if (! sk_spipe_supprs)
   3920   {
   3921 #ifdef HAVE_MESSAGES
   3922     MHD_DLOG (daemon,
   3923               _ ("Failed to suppress SIGPIPE on new client socket: %s\n"),
   3924               MHD_socket_last_strerr_ ());
   3925 #else  /* ! HAVE_MESSAGES */
   3926     (void) 0; /* Mute compiler warning */
   3927 #endif /* ! HAVE_MESSAGES */
   3928 #ifndef MSG_NOSIGNAL
   3929     /* Application expects that SIGPIPE will be suppressed,
   3930      * but suppression failed and SIGPIPE cannot be suppressed with send(). */
   3931     if (! daemon->sigpipe_blocked)
   3932     {
   3933       int err = MHD_socket_get_error_ ();
   3934       MHD_socket_close_ (client_socket);
   3935       MHD_socket_fset_error_ (err);
   3936       return MHD_NO;
   3937     }
   3938 #endif /* MSG_NOSIGNAL */
   3939   }
   3940 #endif /* MHD_socket_nosignal_ */
   3941 
   3942   if ( (0 != (daemon->options & MHD_USE_TURBO)) &&
   3943        (! MHD_socket_noninheritable_ (client_socket)) )
   3944   {
   3945 #ifdef HAVE_MESSAGES
   3946     MHD_DLOG (daemon,
   3947               _ ("Failed to set noninheritable mode on new client socket.\n"));
   3948 #endif
   3949   }
   3950 
   3951   /* Copy to sockaddr_storage structure to avoid alignment problems */
   3952   if (0 < addrlen)
   3953     memcpy (&addrstorage, addr, (size_t) addrlen);
   3954 #ifdef HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN
   3955   addrstorage.ss_len = addrlen; /* Force set the right length */
   3956 #endif /* HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN */
   3957 
   3958 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   3959   if (NULL != daemon->worker_pool)
   3960   {
   3961     unsigned int i;
   3962     /* have a pool, try to find a pool with capacity; we use the
   3963        socket as the initial offset into the pool for load
   3964        balancing */
   3965     for (i = 0; i < daemon->worker_pool_size; ++i)
   3966     {
   3967       struct MHD_Daemon *const worker =
   3968         &daemon->worker_pool[(i + (unsigned int) client_socket)
   3969                              % daemon->worker_pool_size];
   3970       if (worker->connections < worker->connection_limit)
   3971         return internal_add_connection (worker,
   3972                                         client_socket,
   3973                                         &addrstorage,
   3974                                         addrlen,
   3975                                         true,
   3976                                         sk_nonbl,
   3977                                         sk_spipe_supprs,
   3978                                         _MHD_UNKNOWN);
   3979     }
   3980     /* all pools are at their connection limit, must refuse */
   3981     MHD_socket_close_chk_ (client_socket);
   3982 #if defined(ENFILE) && (ENFILE + 0 != 0)
   3983     errno = ENFILE;
   3984 #endif
   3985     return MHD_NO;
   3986   }
   3987 #endif /* MHD_USE_POSIX_THREADS || MHD_USE_W32_THREADS */
   3988 
   3989   return internal_add_connection (daemon,
   3990                                   client_socket,
   3991                                   &addrstorage,
   3992                                   addrlen,
   3993                                   true,
   3994                                   sk_nonbl,
   3995                                   sk_spipe_supprs,
   3996                                   _MHD_UNKNOWN);
   3997 }
   3998 
   3999 
   4000 /**
   4001  * Accept an incoming connection and create the MHD_Connection object for
   4002  * it.  This function also enforces policy by way of checking with the
   4003  * accept policy callback.
   4004  * @remark To be called only from thread that process
   4005  * daemon's select()/poll()/etc.
   4006  *
   4007  * @param daemon handle with the listen socket
   4008  * @return #MHD_YES on success (connections denied by policy or due
   4009  *         to 'out of memory' and similar errors) are still considered
   4010  *         successful as far as #MHD_accept_connection() is concerned);
   4011  *         a return code of #MHD_NO only refers to the actual
   4012  *         accept() system call.
   4013  */
   4014 static enum MHD_Result
   4015 MHD_accept_connection (struct MHD_Daemon *daemon)
   4016 {
   4017   struct sockaddr_storage addrstorage;
   4018   socklen_t addrlen;
   4019   MHD_socket s;
   4020   MHD_socket fd;
   4021   bool sk_nonbl;
   4022   bool sk_spipe_supprs;
   4023   bool sk_cloexec;
   4024   enum MHD_tristate sk_non_ip;
   4025 #if defined(_DEBUG) && defined (USE_ACCEPT4)
   4026   const bool use_accept4 = ! daemon->avoid_accept4;
   4027 #elif defined (USE_ACCEPT4)
   4028   static const bool use_accept4 = true;
   4029 #else  /* ! USE_ACCEPT4 && ! _DEBUG */
   4030   static const bool use_accept4 = false;
   4031 #endif /* ! USE_ACCEPT4 && ! _DEBUG */
   4032 
   4033 #ifdef MHD_USE_THREADS
   4034   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   4035                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   4036   mhd_assert (NULL == daemon->worker_pool);
   4037 #endif /* MHD_USE_THREADS */
   4038 
   4039   if ( (MHD_INVALID_SOCKET == (fd = daemon->listen_fd)) ||
   4040        (daemon->was_quiesced) )
   4041     return MHD_NO;
   4042 
   4043   addrlen = (socklen_t) sizeof (addrstorage);
   4044   memset (&addrstorage,
   4045           0,
   4046           (size_t) addrlen);
   4047 #ifdef HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN
   4048   addrstorage.ss_len = addrlen;
   4049 #endif /* HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN */
   4050 
   4051   /* Initialise with default values to avoid compiler warnings */
   4052   sk_nonbl = false;
   4053   sk_spipe_supprs = false;
   4054   sk_cloexec = false;
   4055   s = MHD_INVALID_SOCKET;
   4056 
   4057 #ifdef USE_ACCEPT4
   4058   if (use_accept4 &&
   4059       (MHD_INVALID_SOCKET !=
   4060        (s = accept4 (fd,
   4061                      (struct sockaddr *) &addrstorage,
   4062                      &addrlen,
   4063                      SOCK_CLOEXEC_OR_ZERO | SOCK_NONBLOCK_OR_ZERO
   4064                      | SOCK_NOSIGPIPE_OR_ZERO))))
   4065   {
   4066     sk_nonbl = (SOCK_NONBLOCK_OR_ZERO != 0);
   4067 #ifndef MHD_WINSOCK_SOCKETS
   4068     sk_spipe_supprs = (SOCK_NOSIGPIPE_OR_ZERO != 0);
   4069 #else  /* MHD_WINSOCK_SOCKETS */
   4070     sk_spipe_supprs = true; /* Nothing to suppress on W32 */
   4071 #endif /* MHD_WINSOCK_SOCKETS */
   4072     sk_cloexec = (SOCK_CLOEXEC_OR_ZERO != 0);
   4073   }
   4074 #endif /* USE_ACCEPT4 */
   4075 #if defined(_DEBUG) || ! defined(USE_ACCEPT4)
   4076   if (! use_accept4 &&
   4077       (MHD_INVALID_SOCKET !=
   4078        (s = accept (fd,
   4079                     (struct sockaddr *) &addrstorage,
   4080                     &addrlen))))
   4081   {
   4082 #ifdef MHD_ACCEPT_INHERIT_NONBLOCK
   4083     sk_nonbl = daemon->listen_nonblk;
   4084 #else  /* ! MHD_ACCEPT_INHERIT_NONBLOCK */
   4085     sk_nonbl = false;
   4086 #endif /* ! MHD_ACCEPT_INHERIT_NONBLOCK */
   4087 #ifndef MHD_WINSOCK_SOCKETS
   4088     sk_spipe_supprs = false;
   4089 #else  /* MHD_WINSOCK_SOCKETS */
   4090     sk_spipe_supprs = true; /* Nothing to suppress on W32 */
   4091 #endif /* MHD_WINSOCK_SOCKETS */
   4092     sk_cloexec = false;
   4093   }
   4094 #endif /* _DEBUG || !USE_ACCEPT4 */
   4095 
   4096   if (MHD_INVALID_SOCKET == s)
   4097   {
   4098     const int err = MHD_socket_get_error_ ();
   4099 
   4100     /* This could be a common occurrence with multiple worker threads */
   4101     if (MHD_SCKT_ERR_IS_ (err,
   4102                           MHD_SCKT_EINVAL_))
   4103       return MHD_NO;   /* can happen during shutdown */
   4104     if (MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_ (err))
   4105       return MHD_NO;   /* do not print error if client just disconnected early */
   4106 #ifdef HAVE_MESSAGES
   4107     if (! MHD_SCKT_ERR_IS_EAGAIN_ (err) )
   4108       MHD_DLOG (daemon,
   4109                 _ ("Error accepting connection: %s\n"),
   4110                 MHD_socket_strerr_ (err));
   4111 #endif
   4112     if (MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err) )
   4113     {
   4114       /* system/process out of resources */
   4115       if (0 == daemon->connections)
   4116       {
   4117 #ifdef HAVE_MESSAGES
   4118         /* Not setting 'at_limit' flag, as there is no way it
   4119            would ever be cleared.  Instead trying to produce
   4120            bit fat ugly warning. */
   4121         MHD_DLOG (daemon,
   4122                   _ ("Hit process or system resource limit at FIRST " \
   4123                      "connection. This is really bad as there is no sane " \
   4124                      "way to proceed. Will try busy waiting for system " \
   4125                      "resources to become magically available.\n"));
   4126 #endif
   4127       }
   4128       else
   4129       {
   4130 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4131         MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   4132 #endif
   4133         daemon->at_limit = true;
   4134 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4135         MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   4136 #endif
   4137 #ifdef HAVE_MESSAGES
   4138         MHD_DLOG (daemon,
   4139                   _ ("Hit process or system resource limit at %u " \
   4140                      "connections, temporarily suspending accept(). " \
   4141                      "Consider setting a lower MHD_OPTION_CONNECTION_LIMIT.\n"),
   4142                   (unsigned int) daemon->connections);
   4143 #endif
   4144       }
   4145     }
   4146     return MHD_NO;
   4147   }
   4148 
   4149   sk_non_ip = daemon->listen_is_unix;
   4150   if (0 >= addrlen)
   4151   {
   4152 #ifdef HAVE_MESSAGES
   4153     if (_MHD_NO != daemon->listen_is_unix)
   4154       MHD_DLOG (daemon,
   4155                 _ ("Accepted socket has zero-length address. "
   4156                    "Processing the new socket as a socket with " \
   4157                    "unknown type.\n"));
   4158 #endif
   4159     addrlen = 0;
   4160     sk_non_ip = _MHD_YES; /* IP-type addresses have non-zero length */
   4161   }
   4162   if (((socklen_t) sizeof (addrstorage)) < addrlen)
   4163   {
   4164     /* Should not happen as 'sockaddr_storage' must be large enough to
   4165      * store any address supported by the system. */
   4166 #ifdef HAVE_MESSAGES
   4167     MHD_DLOG (daemon,
   4168               _ ("Accepted socket address is larger than expected by " \
   4169                  "system headers. Processing the new socket as a socket with " \
   4170                  "unknown type.\n"));
   4171 #endif
   4172     addrlen = 0;
   4173     sk_non_ip = _MHD_YES; /* IP-type addresses must fit */
   4174   }
   4175 
   4176   if (! sk_nonbl && ! MHD_socket_nonblocking_ (s))
   4177   {
   4178 #ifdef HAVE_MESSAGES
   4179     MHD_DLOG (daemon,
   4180               _ ("Failed to set nonblocking mode on incoming connection " \
   4181                  "socket: %s\n"),
   4182               MHD_socket_last_strerr_ ());
   4183 #else  /* ! HAVE_MESSAGES */
   4184     (void) 0; /* Mute compiler warning */
   4185 #endif /* ! HAVE_MESSAGES */
   4186   }
   4187   else
   4188     sk_nonbl = true;
   4189 
   4190   if (! sk_cloexec && ! MHD_socket_noninheritable_ (s))
   4191   {
   4192 #ifdef HAVE_MESSAGES
   4193     MHD_DLOG (daemon,
   4194               _ ("Failed to set noninheritable mode on incoming connection " \
   4195                  "socket.\n"));
   4196 #else  /* ! HAVE_MESSAGES */
   4197     (void) 0; /* Mute compiler warning */
   4198 #endif /* ! HAVE_MESSAGES */
   4199   }
   4200 
   4201 #if defined(MHD_socket_nosignal_)
   4202   if (! sk_spipe_supprs && ! MHD_socket_nosignal_ (s))
   4203   {
   4204 #ifdef HAVE_MESSAGES
   4205     MHD_DLOG (daemon,
   4206               _ ("Failed to suppress SIGPIPE on incoming connection " \
   4207                  "socket: %s\n"),
   4208               MHD_socket_last_strerr_ ());
   4209 #else  /* ! HAVE_MESSAGES */
   4210     (void) 0; /* Mute compiler warning */
   4211 #endif /* ! HAVE_MESSAGES */
   4212 #ifndef MSG_NOSIGNAL
   4213     /* Application expects that SIGPIPE will be suppressed,
   4214      * but suppression failed and SIGPIPE cannot be suppressed with send(). */
   4215     if (! daemon->sigpipe_blocked)
   4216     {
   4217       (void) MHD_socket_close_ (s);
   4218       return MHD_NO;
   4219     }
   4220 #endif /* MSG_NOSIGNAL */
   4221   }
   4222   else
   4223     sk_spipe_supprs = true;
   4224 #endif /* MHD_socket_nosignal_ */
   4225 #ifdef HAVE_MESSAGES
   4226 #if _MHD_DEBUG_CONNECT
   4227   MHD_DLOG (daemon,
   4228             _ ("Accepted connection on socket %d\n"),
   4229             s);
   4230 #endif
   4231 #endif
   4232   (void) internal_add_connection (daemon,
   4233                                   s,
   4234                                   &addrstorage,
   4235                                   addrlen,
   4236                                   false,
   4237                                   sk_nonbl,
   4238                                   sk_spipe_supprs,
   4239                                   sk_non_ip);
   4240   return MHD_YES;
   4241 }
   4242 
   4243 
   4244 /**
   4245  * Free resources associated with all closed connections.
   4246  * (destroy responses, free buffers, etc.).  All closed
   4247  * connections are kept in the "cleanup" doubly-linked list.
   4248  * @remark To be called only from thread that
   4249  * process daemon's select()/poll()/etc.
   4250  *
   4251  * @param daemon daemon to clean up
   4252  */
   4253 static void
   4254 MHD_cleanup_connections (struct MHD_Daemon *daemon)
   4255 {
   4256   struct MHD_Connection *pos;
   4257 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4258   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   4259                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   4260   mhd_assert (NULL == daemon->worker_pool);
   4261 
   4262   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   4263 #endif
   4264   while (NULL != (pos = daemon->cleanup_tail))
   4265   {
   4266     DLL_remove (daemon->cleanup_head,
   4267                 daemon->cleanup_tail,
   4268                 pos);
   4269 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4270     MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   4271     if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon) &&
   4272         (! pos->thread_joined) &&
   4273         (! MHD_thread_handle_ID_join_thread_ (pos->tid)) )
   4274       MHD_PANIC (_ ("Failed to join a thread.\n"));
   4275 #endif
   4276 #ifdef UPGRADE_SUPPORT
   4277     cleanup_upgraded_connection (pos);
   4278 #endif /* UPGRADE_SUPPORT */
   4279     MHD_pool_destroy (pos->pool);
   4280 #ifdef HTTPS_SUPPORT
   4281     if (NULL != pos->tls_session)
   4282       gnutls_deinit (pos->tls_session);
   4283 #endif /* HTTPS_SUPPORT */
   4284 
   4285     /* clean up the connection */
   4286     if (NULL != daemon->notify_connection)
   4287       daemon->notify_connection (daemon->notify_connection_cls,
   4288                                  pos,
   4289                                  &pos->socket_context,
   4290                                  MHD_CONNECTION_NOTIFY_CLOSED);
   4291     MHD_ip_limit_del (daemon,
   4292                       pos->addr,
   4293                       pos->addr_len);
   4294 #ifdef EPOLL_SUPPORT
   4295     if (MHD_D_IS_USING_EPOLL_ (daemon))
   4296     {
   4297       if (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
   4298       {
   4299         EDLL_remove (daemon->eready_head,
   4300                      daemon->eready_tail,
   4301                      pos);
   4302         pos->epoll_state &=
   4303           ~((enum MHD_EpollState) MHD_EPOLL_STATE_IN_EREADY_EDLL);
   4304       }
   4305       if ( (-1 != daemon->epoll_fd) &&
   4306            (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET)) )
   4307       {
   4308         /* epoll documentation suggests that closing a FD
   4309            automatically removes it from the epoll set; however,
   4310            this is not true as if we fail to do manually remove it,
   4311            we are still seeing an event for this fd in epoll,
   4312            causing grief (use-after-free...) --- at least on my
   4313            system. */
   4314         if (0 != epoll_ctl (daemon->epoll_fd,
   4315                             EPOLL_CTL_DEL,
   4316                             pos->socket_fd,
   4317                             NULL))
   4318           MHD_PANIC (_ ("Failed to remove FD from epoll set.\n"));
   4319         pos->epoll_state &=
   4320           ~((enum MHD_EpollState)
   4321             MHD_EPOLL_STATE_IN_EPOLL_SET);
   4322       }
   4323     }
   4324 #endif
   4325     if (NULL != pos->rp.response)
   4326     {
   4327       MHD_destroy_response (pos->rp.response);
   4328       pos->rp.response = NULL;
   4329     }
   4330     if (MHD_INVALID_SOCKET != pos->socket_fd)
   4331       MHD_socket_close_chk_ (pos->socket_fd);
   4332     if (MHD_ITC_IS_VALID_ (pos->resume_itc))
   4333       MHD_itc_destroy_chk_ (pos->resume_itc);
   4334     if (NULL != pos->addr)
   4335       free (pos->addr);
   4336     free (pos);
   4337 
   4338 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4339     MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   4340 #endif
   4341     daemon->connections--;
   4342     daemon->at_limit = false;
   4343   }
   4344 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4345   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   4346 #endif
   4347 }
   4348 
   4349 
   4350 /**
   4351  * Obtain timeout value for polling function for this daemon.
   4352  *
   4353  * This function set value to the amount of milliseconds for which polling
   4354  * function (`select()`, `poll()` or epoll) should at most block, not the
   4355  * timeout value set for connections.
   4356  *
   4357  * Any "external" sockets polling function must be called with the timeout
   4358  * value provided by this function. Smaller timeout values can be used for
   4359  * polling function if it is required for any reason, but using larger
   4360  * timeout value or no timeout (indefinite timeout) when this function
   4361  * return #MHD_YES will break MHD processing logic and result in "hung"
   4362  * connections with data pending in network buffers and other problems.
   4363  *
   4364  * It is important to always use this function (or #MHD_get_timeout64(),
   4365  * #MHD_get_timeout64s(), #MHD_get_timeout_i() functions) when "external"
   4366  * polling is used.
   4367  * If this function returns #MHD_YES then #MHD_run() (or #MHD_run_from_select())
   4368  * must be called right after return from polling function, regardless of
   4369  * the states of MHD FDs.
   4370  *
   4371  * In practice, if #MHD_YES is returned then #MHD_run() (or
   4372  * #MHD_run_from_select()) must be called not later than @a timeout
   4373  * millisecond even if no activity is detected on sockets by sockets
   4374  * polling function.
   4375  * @remark To be called only from thread that process
   4376  * daemon's select()/poll()/etc.
   4377  *
   4378  * @param daemon daemon to query for timeout
   4379  * @param[out] timeout set to the timeout (in milliseconds)
   4380  * @return #MHD_YES on success, #MHD_NO if timeouts are
   4381  *         not used and no data processing is pending.
   4382  * @ingroup event
   4383  */
   4384 _MHD_EXTERN enum MHD_Result
   4385 MHD_get_timeout (struct MHD_Daemon *daemon,
   4386                  MHD_UNSIGNED_LONG_LONG *timeout)
   4387 {
   4388   uint64_t t64;
   4389   if (MHD_NO == MHD_get_timeout64 (daemon, &t64))
   4390     return MHD_NO;
   4391 
   4392 #if SIZEOF_UINT64_T > SIZEOF_UNSIGNED_LONG_LONG
   4393   if (ULLONG_MAX <= t64)
   4394     *timeout = ULLONG_MAX;
   4395   else
   4396 #endif /* SIZEOF_UINT64_T > SIZEOF_UNSIGNED_LONG_LONG */
   4397   *timeout = (MHD_UNSIGNED_LONG_LONG) t64;
   4398   return MHD_YES;
   4399 }
   4400 
   4401 
   4402 /**
   4403  * Obtain timeout value for external polling function for this daemon.
   4404  *
   4405  * This function set value to the amount of milliseconds for which polling
   4406  * function (`select()`, `poll()` or epoll) should at most block, not the
   4407  * timeout value set for connections.
   4408  *
   4409  * Any "external" sockets polling function must be called with the timeout
   4410  * value provided by this function. Smaller timeout values can be used for
   4411  * polling function if it is required for any reason, but using larger
   4412  * timeout value or no timeout (indefinite timeout) when this function
   4413  * return #MHD_YES will break MHD processing logic and result in "hung"
   4414  * connections with data pending in network buffers and other problems.
   4415  *
   4416  * It is important to always use this function (or #MHD_get_timeout(),
   4417  * #MHD_get_timeout64s(), #MHD_get_timeout_i() functions) when "external"
   4418  * polling is used.
   4419  * If this function returns #MHD_YES then #MHD_run() (or #MHD_run_from_select())
   4420  * must be called right after return from polling function, regardless of
   4421  * the states of MHD FDs.
   4422  *
   4423  * In practice, if #MHD_YES is returned then #MHD_run() (or
   4424  * #MHD_run_from_select()) must be called not later than @a timeout
   4425  * millisecond even if no activity is detected on sockets by sockets
   4426  * polling function.
   4427  * @remark To be called only from thread that process
   4428  * daemon's select()/poll()/etc.
   4429  *
   4430  * @param daemon daemon to query for timeout
   4431  * @param[out] timeout64 the pointer to the variable to be set to the
   4432  *                  timeout (in milliseconds)
   4433  * @return #MHD_YES if timeout value has been set,
   4434  *         #MHD_NO if timeouts are not used and no data processing is pending.
   4435  * @note Available since #MHD_VERSION 0x00097701
   4436  * @ingroup event
   4437  */
   4438 _MHD_EXTERN enum MHD_Result
   4439 MHD_get_timeout64 (struct MHD_Daemon *daemon,
   4440                    uint64_t *timeout64)
   4441 {
   4442   uint64_t earliest_deadline;
   4443   struct MHD_Connection *pos;
   4444   struct MHD_Connection *earliest_tmot_conn; /**< the connection with earliest timeout */
   4445   bool resuming; /**< the copy of @a daemon->resuming, read under the lock */
   4446 
   4447 #ifdef MHD_USE_THREADS
   4448   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   4449                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   4450 #endif /* MHD_USE_THREADS */
   4451 
   4452   if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   4453   {
   4454 #ifdef HAVE_MESSAGES
   4455     MHD_DLOG (daemon,
   4456               _ ("Illegal call to MHD_get_timeout.\n"));
   4457 #endif
   4458     return MHD_NO;
   4459   }
   4460   /* Unlike the other flags checked below, which are touched only by the
   4461      thread that processes this daemon's polling, 'resuming' is set by
   4462      #MHD_resume_connection(), which the application may legally call from
   4463      any thread.  It is guarded by 'cleanup_connection_mutex' everywhere. */
   4464 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4465   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   4466 #endif
   4467   resuming = daemon->resuming;
   4468 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   4469   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   4470 #endif
   4471   if (daemon->data_already_pending
   4472       || (NULL != daemon->cleanup_head)
   4473       || resuming
   4474       || daemon->have_new
   4475       || daemon->shutdown)
   4476   {
   4477     /* Some data or connection statuses already waiting to be processed. */
   4478     *timeout64 = 0;
   4479     return MHD_YES;
   4480   }
   4481 #ifdef EPOLL_SUPPORT
   4482   if (MHD_D_IS_USING_EPOLL_ (daemon) &&
   4483       ((NULL != daemon->eready_head)
   4484 #if defined(UPGRADE_SUPPORT) && defined(HTTPS_SUPPORT)
   4485        || (NULL != daemon->eready_urh_head)
   4486 #endif /* UPGRADE_SUPPORT && HTTPS_SUPPORT */
   4487       ) )
   4488   {
   4489     /* Some connection(s) already have some data pending. */
   4490     *timeout64 = 0;
   4491     return MHD_YES;
   4492   }
   4493 #endif /* EPOLL_SUPPORT */
   4494 
   4495   earliest_tmot_conn = NULL;
   4496   earliest_deadline = 0; /* mute compiler warning */
   4497   /* normal timeouts are sorted, so we only need to look at the 'tail' (oldest) */
   4498   pos = daemon->normal_timeout_tail;
   4499   if ( (NULL != pos) &&
   4500        (0 != pos->connection_timeout_ms) )
   4501   {
   4502     earliest_tmot_conn = pos;
   4503     earliest_deadline = pos->last_activity + pos->connection_timeout_ms;
   4504   }
   4505 
   4506   for (pos = daemon->manual_timeout_tail;
   4507        NULL != pos;
   4508        pos = pos->prevX)
   4509   {
   4510     if (0 != pos->connection_timeout_ms)
   4511     {
   4512       if ( (NULL == earliest_tmot_conn) ||
   4513            (earliest_deadline >
   4514             pos->last_activity + pos->connection_timeout_ms) )
   4515       {
   4516         earliest_tmot_conn = pos;
   4517         earliest_deadline = pos->last_activity + pos->connection_timeout_ms;
   4518       }
   4519     }
   4520   }
   4521 
   4522   if (NULL != earliest_tmot_conn)
   4523   {
   4524     *timeout64 = connection_get_wait (earliest_tmot_conn);
   4525     return MHD_YES;
   4526   }
   4527   return MHD_NO;
   4528 }
   4529 
   4530 
   4531 #if defined(HAVE_POLL) || defined(EPOLL_SUPPORT)
   4532 /**
   4533  * Obtain timeout value for external polling function for this daemon.
   4534  *
   4535  * This function set value to the amount of milliseconds for which polling
   4536  * function (`select()`, `poll()` or epoll) should at most block, not the
   4537  * timeout value set for connections.
   4538  *
   4539  * Any "external" sockets polling function must be called with the timeout
   4540  * value provided by this function (if returned value is non-negative).
   4541  * Smaller timeout values can be used for polling function if it is required
   4542  * for any reason, but using larger timeout value or no timeout (indefinite
   4543  * timeout) when this function returns non-negative value will break MHD
   4544  * processing logic and result in "hung" connections with data pending in
   4545  * network buffers and other problems.
   4546  *
   4547  * It is important to always use this function (or #MHD_get_timeout(),
   4548  * #MHD_get_timeout64(), #MHD_get_timeout_i() functions) when "external"
   4549  * polling is used.
   4550  * If this function returns non-negative value then #MHD_run() (or
   4551  * #MHD_run_from_select()) must be called right after return from polling
   4552  * function, regardless of the states of MHD FDs.
   4553  *
   4554  * In practice, if zero or positive value is returned then #MHD_run() (or
   4555  * #MHD_run_from_select()) must be called not later than returned amount of
   4556  * millisecond even if no activity is detected on sockets by sockets
   4557  * polling function.
   4558  * @remark To be called only from thread that process
   4559  * daemon's select()/poll()/etc.
   4560  *
   4561  * @param daemon the daemon to query for timeout
   4562  * @return -1 if connections' timeouts are not set and no data processing
   4563  *         is pending, so external polling function may wait for sockets
   4564  *         activity for indefinite amount of time,
   4565  *         otherwise returned value is the the maximum amount of millisecond
   4566  *         that external polling function must wait for the activity of FDs.
   4567  * @note Available since #MHD_VERSION 0x00097701
   4568  * @ingroup event
   4569  */
   4570 _MHD_EXTERN int64_t
   4571 MHD_get_timeout64s (struct MHD_Daemon *daemon)
   4572 {
   4573   uint64_t utimeout;
   4574   if (MHD_NO == MHD_get_timeout64 (daemon, &utimeout))
   4575     return -1;
   4576   if (INT64_MAX < utimeout)
   4577     return INT64_MAX;
   4578 
   4579   return (int64_t) utimeout;
   4580 }
   4581 
   4582 
   4583 /**
   4584  * Obtain timeout value for external polling function for this daemon.
   4585  *
   4586  * This function set value to the amount of milliseconds for which polling
   4587  * function (`select()`, `poll()` or epoll) should at most block, not the
   4588  * timeout value set for connections.
   4589  *
   4590  * Any "external" sockets polling function must be called with the timeout
   4591  * value provided by this function (if returned value is non-negative).
   4592  * Smaller timeout values can be used for polling function if it is required
   4593  * for any reason, but using larger timeout value or no timeout (indefinite
   4594  * timeout) when this function returns non-negative value will break MHD
   4595  * processing logic and result in "hung" connections with data pending in
   4596  * network buffers and other problems.
   4597  *
   4598  * It is important to always use this function (or #MHD_get_timeout(),
   4599  * #MHD_get_timeout64(), #MHD_get_timeout64s() functions) when "external"
   4600  * polling is used.
   4601  * If this function returns non-negative value then #MHD_run() (or
   4602  * #MHD_run_from_select()) must be called right after return from polling
   4603  * function, regardless of the states of MHD FDs.
   4604  *
   4605  * In practice, if zero or positive value is returned then #MHD_run() (or
   4606  * #MHD_run_from_select()) must be called not later than returned amount of
   4607  * millisecond even if no activity is detected on sockets by sockets
   4608  * polling function.
   4609  * @remark To be called only from thread that process
   4610  * daemon's select()/poll()/etc.
   4611  *
   4612  * @param daemon the daemon to query for timeout
   4613  * @return -1 if connections' timeouts are not set and no data processing
   4614  *         is pending, so external polling function may wait for sockets
   4615  *         activity for indefinite amount of time,
   4616  *         otherwise returned value is the the maximum amount of millisecond
   4617  *         (capped at INT_MAX) that external polling function must wait
   4618  *         for the activity of FDs.
   4619  * @note Available since #MHD_VERSION 0x00097701
   4620  * @ingroup event
   4621  */
   4622 _MHD_EXTERN int
   4623 MHD_get_timeout_i (struct MHD_Daemon *daemon)
   4624 {
   4625 #if SIZEOF_INT >= SIZEOF_INT64_T
   4626   return MHD_get_timeout64s (daemon);
   4627 #else  /* SIZEOF_INT < SIZEOF_INT64_T */
   4628   const int64_t to64 = MHD_get_timeout64s (daemon);
   4629   if (INT_MAX >= to64)
   4630     return (int) to64;
   4631   return INT_MAX;
   4632 #endif /* SIZEOF_INT < SIZEOF_INT64_T */
   4633 }
   4634 
   4635 
   4636 /**
   4637  * Obtain timeout value for polling function for this daemon.
   4638  * @remark To be called only from the thread that processes
   4639  * daemon's select()/poll()/etc.
   4640  *
   4641  * @param daemon the daemon to query for timeout
   4642  * @param max_timeout the maximum return value (in milliseconds),
   4643  *                    ignored if set to '-1'
   4644  * @return timeout value in milliseconds or -1 if no timeout is expected.
   4645  */
   4646 static int64_t
   4647 get_timeout_millisec_ (struct MHD_Daemon *daemon,
   4648                        int32_t max_timeout)
   4649 {
   4650   uint64_t d_timeout;
   4651   mhd_assert (0 <= max_timeout || -1 == max_timeout);
   4652   if (0 == max_timeout)
   4653     return 0;
   4654 
   4655   if (MHD_NO == MHD_get_timeout64 (daemon, &d_timeout))
   4656     return max_timeout;
   4657 
   4658   if ((0 < max_timeout) && ((uint64_t) max_timeout < d_timeout))
   4659     return max_timeout;
   4660 
   4661   if (INT64_MAX <= d_timeout)
   4662     return INT64_MAX;
   4663 
   4664   return (int64_t) d_timeout;
   4665 }
   4666 
   4667 
   4668 /**
   4669  * Obtain timeout value for polling function for this daemon.
   4670  * @remark To be called only from the thread that processes
   4671  * daemon's select()/poll()/etc.
   4672  *
   4673  * @param daemon the daemon to query for timeout
   4674  * @param max_timeout the maximum return value (in milliseconds),
   4675  *                    ignored if set to '-1'
   4676  * @return timeout value in milliseconds, capped to INT_MAX, or
   4677  *         -1 if no timeout is expected.
   4678  */
   4679 static int
   4680 get_timeout_millisec_int (struct MHD_Daemon *daemon,
   4681                           int32_t max_timeout)
   4682 {
   4683   int64_t res;
   4684 
   4685   res = get_timeout_millisec_ (daemon, max_timeout);
   4686 #if SIZEOF_INT < SIZEOF_INT64_T
   4687   if (INT_MAX <= res)
   4688     return INT_MAX;
   4689 #endif /* SIZEOF_INT < SIZEOF_INT64_T */
   4690   return (int) res;
   4691 }
   4692 
   4693 
   4694 #endif /* HAVE_POLL || EPOLL_SUPPORT */
   4695 
   4696 /**
   4697  * Internal version of #MHD_run_from_select().
   4698  *
   4699  * @param daemon daemon to run select loop for
   4700  * @param read_fd_set read set
   4701  * @param write_fd_set write set
   4702  * @param except_fd_set except set
   4703  * @param fd_setsize value of FD_SETSIZE used when fd_sets were created
   4704  * @return #MHD_NO on serious errors, #MHD_YES on success
   4705  * @ingroup event
   4706  */
   4707 static enum MHD_Result
   4708 internal_run_from_select (struct MHD_Daemon *daemon,
   4709                           const fd_set *read_fd_set,
   4710                           const fd_set *write_fd_set,
   4711                           const fd_set *except_fd_set,
   4712                           int fd_setsize)
   4713 {
   4714   MHD_socket ds;
   4715 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   4716   struct MHD_UpgradeResponseHandle *urh;
   4717   struct MHD_UpgradeResponseHandle *urhn;
   4718 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   4719 
   4720   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   4721               (MHD_thread_handle_ID_is_valid_ID_ (daemon->tid)));
   4722   mhd_assert ((0 != (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   4723               (! MHD_thread_handle_ID_is_valid_ID_ (daemon->tid)));
   4724   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   4725               (MHD_thread_handle_ID_is_current_thread_ (daemon->tid)));
   4726 
   4727   mhd_assert (0 < fd_setsize);
   4728   (void) fd_setsize; /* Mute compiler warning */
   4729 #ifndef HAS_FD_SETSIZE_OVERRIDABLE
   4730   (void) fd_setsize; /* Mute compiler warning */
   4731   mhd_assert (((int) FD_SETSIZE) <= fd_setsize);
   4732   fd_setsize = FD_SETSIZE; /* Help compiler to optimise */
   4733 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   4734 
   4735   /* Clear ITC to avoid spinning select */
   4736   /* Do it before any other processing so new signals
   4737      will trigger select again and will be processed */
   4738   if (MHD_ITC_IS_VALID_ (daemon->itc))
   4739   { /* Have ITC */
   4740     bool need_to_clear_itc = true; /* ITC is always non-blocking, it is safe to clear even if ITC not activated */
   4741     if (MHD_SCKT_FD_FITS_FDSET_SETSIZE_ (MHD_itc_r_fd_ (daemon->itc),
   4742                                          NULL, fd_setsize))
   4743       need_to_clear_itc = FD_ISSET (MHD_itc_r_fd_ (daemon->itc), \
   4744                                     (fd_set *) _MHD_DROP_CONST (read_fd_set)); /* Skip clearing, if not needed */
   4745     if (need_to_clear_itc)
   4746       MHD_itc_clear_ (daemon->itc);
   4747   }
   4748 
   4749   /* Reset. New value will be set when connections are processed. */
   4750   /* Note: no-op for thread-per-connection as it is always false in that mode. */
   4751   daemon->data_already_pending = false;
   4752 
   4753   /* Process externally added connection if any */
   4754   if (daemon->have_new)
   4755     new_connections_list_process_ (daemon);
   4756 
   4757   /* select connection thread handling type */
   4758   ds = daemon->listen_fd;
   4759   if ( (MHD_INVALID_SOCKET != ds) &&
   4760        (! daemon->was_quiesced) )
   4761   {
   4762     bool need_to_accept;
   4763     if (MHD_SCKT_FD_FITS_FDSET_SETSIZE_ (ds, NULL, fd_setsize))
   4764       need_to_accept = FD_ISSET (ds,
   4765                                  (fd_set *) _MHD_DROP_CONST (read_fd_set));
   4766     else                                       /* Cannot check whether new connection are pending */
   4767       need_to_accept = daemon->listen_nonblk;  /* Try to accept if non-blocking */
   4768 
   4769     if (need_to_accept)
   4770       (void) MHD_accept_connection (daemon);
   4771   }
   4772 
   4773   if (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   4774   {
   4775     /* do not have a thread per connection, process all connections now */
   4776     struct MHD_Connection *pos;
   4777     struct MHD_Connection *prev;
   4778 
   4779     for (pos = daemon->connections_tail; NULL != pos; pos = prev)
   4780     {
   4781       MHD_socket cs;
   4782       bool r_ready;
   4783       bool w_ready;
   4784       bool has_err;
   4785 
   4786       prev = pos->prev;
   4787       cs = pos->socket_fd;
   4788       if (MHD_INVALID_SOCKET == cs)
   4789         continue;
   4790 
   4791       if (MHD_SCKT_FD_FITS_FDSET_SETSIZE_ (cs, NULL, fd_setsize))
   4792       {
   4793         r_ready = FD_ISSET (cs,
   4794                             (fd_set *) _MHD_DROP_CONST (read_fd_set));
   4795         w_ready = FD_ISSET (cs,
   4796                             (fd_set *) _MHD_DROP_CONST (write_fd_set));
   4797         has_err = (NULL != except_fd_set) &&
   4798                   FD_ISSET (cs,
   4799                             (fd_set *) _MHD_DROP_CONST (except_fd_set));
   4800       }
   4801       else
   4802       { /* Cannot check the real readiness */
   4803         r_ready = pos->sk_nonblck;
   4804         w_ready = r_ready;
   4805         has_err = false;
   4806       }
   4807       call_handlers (pos,
   4808                      r_ready,
   4809                      w_ready,
   4810                      has_err);
   4811     }
   4812   }
   4813 
   4814 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   4815   /* handle upgraded HTTPS connections */
   4816   for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
   4817   {
   4818     urhn = urh->prev;
   4819     /* update urh state based on select() output */
   4820     urh_from_fdset (urh,
   4821                     read_fd_set,
   4822                     write_fd_set,
   4823                     except_fd_set,
   4824                     fd_setsize);
   4825     /* call generic forwarding function for passing data */
   4826     process_urh (urh);
   4827     /* Finished forwarding? */
   4828     if ( (0 == urh->in_buffer_size) &&
   4829          (0 == urh->out_buffer_size) &&
   4830          (0 == urh->in_buffer_used) &&
   4831          (0 == urh->out_buffer_used) )
   4832     {
   4833       MHD_connection_finish_forward_ (urh->connection);
   4834       urh->clean_ready = true;
   4835       /* Resuming will move connection to cleanup list. */
   4836       MHD_resume_connection (urh->connection);
   4837     }
   4838   }
   4839 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   4840   MHD_cleanup_connections (daemon);
   4841   return MHD_YES;
   4842 }
   4843 
   4844 
   4845 #undef MHD_run_from_select
   4846 
   4847 /**
   4848  * Run webserver operations. This method should be called by clients
   4849  * in combination with #MHD_get_fdset and #MHD_get_timeout() if the
   4850  * client-controlled select method is used.
   4851  * This function specifies FD_SETSIZE used when provided fd_sets were
   4852  * created. It is important on platforms where FD_SETSIZE can be
   4853  * overridden.
   4854  *
   4855  * You can use this function instead of #MHD_run if you called
   4856  * 'select()' on the result from #MHD_get_fdset2().  File descriptors in
   4857  * the sets that are not controlled by MHD will be ignored.  Calling
   4858  * this function instead of #MHD_run() is more efficient as MHD will
   4859  * not have to call 'select()' again to determine which operations are
   4860  * ready.
   4861  *
   4862  * If #MHD_get_timeout() returned #MHD_YES, than this function must be
   4863  * called right after 'select()' returns regardless of detected activity
   4864  * on the daemon's FDs.
   4865  *
   4866  * This function cannot be used with daemon started with
   4867  * #MHD_USE_INTERNAL_POLLING_THREAD flag.
   4868  *
   4869  * @param daemon the daemon to run select loop for
   4870  * @param read_fd_set the read set
   4871  * @param write_fd_set the write set
   4872  * @param except_fd_set the except set
   4873  * @param fd_setsize the value of FD_SETSIZE
   4874  * @return #MHD_NO on serious errors, #MHD_YES on success
   4875  * @sa #MHD_get_fdset2(), #MHD_OPTION_APP_FD_SETSIZE
   4876  * @ingroup event
   4877  */
   4878 _MHD_EXTERN enum MHD_Result
   4879 MHD_run_from_select2 (struct MHD_Daemon *daemon,
   4880                       const fd_set *read_fd_set,
   4881                       const fd_set *write_fd_set,
   4882                       const fd_set *except_fd_set,
   4883                       unsigned int fd_setsize)
   4884 {
   4885   if (MHD_D_IS_USING_POLL_ (daemon) ||
   4886       MHD_D_IS_USING_THREADS_ (daemon))
   4887     return MHD_NO;
   4888   if ((NULL == read_fd_set) || (NULL == write_fd_set))
   4889     return MHD_NO;
   4890 #ifdef HAVE_MESSAGES
   4891   if (NULL == except_fd_set)
   4892   {
   4893     MHD_DLOG (daemon,
   4894               _ ("MHD_run_from_select() called with except_fd_set "
   4895                  "set to NULL. Such behavior is deprecated.\n"));
   4896   }
   4897 #endif /* HAVE_MESSAGES */
   4898 
   4899 #ifdef HAS_FD_SETSIZE_OVERRIDABLE
   4900   if (0 == fd_setsize)
   4901     return MHD_NO;
   4902   else if (((unsigned int) INT_MAX) < fd_setsize)
   4903     fd_setsize = (unsigned int) INT_MAX;
   4904 #ifdef HAVE_MESSAGES
   4905   else if (daemon->fdset_size > ((int) fd_setsize))
   4906   {
   4907     if (daemon->fdset_size_set_by_app)
   4908     {
   4909       MHD_DLOG (daemon,
   4910                 _ ("%s() called with fd_setsize (%u) " \
   4911                    "less than value set by MHD_OPTION_APP_FD_SETSIZE (%d). " \
   4912                    "Some socket FDs may be not processed. " \
   4913                    "Use MHD_OPTION_APP_FD_SETSIZE with the correct value.\n"),
   4914                 "MHD_run_from_select2", fd_setsize, daemon->fdset_size);
   4915     }
   4916     else
   4917     {
   4918       MHD_DLOG (daemon,
   4919                 _ ("%s() called with fd_setsize (%u) " \
   4920                    "less than FD_SETSIZE used by MHD (%d). " \
   4921                    "Some socket FDs may be not processed. " \
   4922                    "Consider using MHD_OPTION_APP_FD_SETSIZE option.\n"),
   4923                 "MHD_run_from_select2", fd_setsize, daemon->fdset_size);
   4924     }
   4925   }
   4926 #endif /* HAVE_MESSAGES */
   4927 #else  /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   4928   if (((unsigned int) FD_SETSIZE) > fd_setsize)
   4929   {
   4930 #ifdef HAVE_MESSAGES
   4931     MHD_DLOG (daemon,
   4932               _ ("%s() called with fd_setsize (%u) " \
   4933                  "less than fixed FD_SETSIZE value (%d) used on the " \
   4934                  "platform.\n"),
   4935               "MHD_run_from_select2", fd_setsize, (int) FD_SETSIZE);
   4936 #endif /* HAVE_MESSAGES */
   4937     return MHD_NO;
   4938   }
   4939 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   4940 
   4941   if (MHD_D_IS_USING_EPOLL_ (daemon))
   4942   {
   4943 #ifdef EPOLL_SUPPORT
   4944     enum MHD_Result ret = MHD_epoll (daemon,
   4945                                      0);
   4946 
   4947     MHD_cleanup_connections (daemon);
   4948     return ret;
   4949 #else  /* ! EPOLL_SUPPORT */
   4950     return MHD_NO;
   4951 #endif /* ! EPOLL_SUPPORT */
   4952   }
   4953 
   4954   /* Resuming external connections when using an extern mainloop  */
   4955   if (0 != (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME))
   4956     resume_suspended_connections (daemon);
   4957 
   4958   return internal_run_from_select (daemon,
   4959                                    read_fd_set,
   4960                                    write_fd_set,
   4961                                    except_fd_set,
   4962                                    (int) fd_setsize);
   4963 }
   4964 
   4965 
   4966 /**
   4967  * Run webserver operations. This method should be called by clients
   4968  * in combination with #MHD_get_fdset and #MHD_get_timeout() if the
   4969  * client-controlled select method is used.
   4970  *
   4971  * You can use this function instead of #MHD_run if you called
   4972  * `select()` on the result from #MHD_get_fdset.  File descriptors in
   4973  * the sets that are not controlled by MHD will be ignored.  Calling
   4974  * this function instead of #MHD_run is more efficient as MHD will
   4975  * not have to call `select()` again to determine which operations are
   4976  * ready.
   4977  *
   4978  * If #MHD_get_timeout() returned #MHD_YES, than this function must be
   4979  * called right after `select()` returns regardless of detected activity
   4980  * on the daemon's FDs.
   4981  *
   4982  * This function cannot be used with daemon started with
   4983  * #MHD_USE_INTERNAL_POLLING_THREAD flag.
   4984  *
   4985  * @param daemon daemon to run select loop for
   4986  * @param read_fd_set read set
   4987  * @param write_fd_set write set
   4988  * @param except_fd_set except set
   4989  * @return #MHD_NO on serious errors, #MHD_YES on success
   4990  * @ingroup event
   4991  */
   4992 _MHD_EXTERN enum MHD_Result
   4993 MHD_run_from_select (struct MHD_Daemon *daemon,
   4994                      const fd_set *read_fd_set,
   4995                      const fd_set *write_fd_set,
   4996                      const fd_set *except_fd_set)
   4997 {
   4998   return MHD_run_from_select2 (daemon,
   4999                                read_fd_set,
   5000                                write_fd_set,
   5001                                except_fd_set,
   5002 #ifdef HAS_FD_SETSIZE_OVERRIDABLE
   5003                                daemon->fdset_size_set_by_app ?
   5004                                ((unsigned int) daemon->fdset_size) :
   5005                                ((unsigned int) _MHD_SYS_DEFAULT_FD_SETSIZE)
   5006 #else  /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   5007                                ((unsigned int) _MHD_SYS_DEFAULT_FD_SETSIZE)
   5008 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
   5009                                );
   5010 }
   5011 
   5012 
   5013 /**
   5014  * Main internal select() call.  Will compute select sets, call select()
   5015  * and then #internal_run_from_select with the result.
   5016  *
   5017  * @param daemon daemon to run select() loop for
   5018  * @param millisec the maximum time in milliseconds to wait for events,
   5019  *                 set to '0' for non-blocking processing,
   5020  *                 set to '-1' to wait indefinitely.
   5021  * @return #MHD_NO on serious errors, #MHD_YES on success
   5022  */
   5023 static enum MHD_Result
   5024 MHD_select (struct MHD_Daemon *daemon,
   5025             int32_t millisec)
   5026 {
   5027   int num_ready;
   5028   fd_set rs;
   5029   fd_set ws;
   5030   fd_set es;
   5031   MHD_socket maxsock;
   5032   struct timeval timeout;
   5033   struct timeval *tv;
   5034   int err_state;
   5035   MHD_socket ls;
   5036 
   5037   timeout.tv_sec = 0;
   5038   timeout.tv_usec = 0;
   5039   if (daemon->shutdown)
   5040     return MHD_NO;
   5041   FD_ZERO (&rs);
   5042   FD_ZERO (&ws);
   5043   FD_ZERO (&es);
   5044   maxsock = MHD_INVALID_SOCKET;
   5045   err_state = MHD_NO;
   5046   if ( (0 != (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME)) &&
   5047        (MHD_NO != resume_suspended_connections (daemon)) &&
   5048        (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon)) )
   5049     millisec = 0;
   5050 
   5051   if (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   5052   {
   5053     /* single-threaded, go over everything */
   5054     if (MHD_NO ==
   5055         internal_get_fdset2 (daemon,
   5056                              &rs,
   5057                              &ws,
   5058                              &es,
   5059                              &maxsock,
   5060                              (int) FD_SETSIZE))
   5061     {
   5062 #ifdef HAVE_MESSAGES
   5063       MHD_DLOG (daemon,
   5064                 _ ("Could not obtain daemon fdsets.\n"));
   5065 #endif
   5066       err_state = MHD_YES;
   5067     }
   5068   }
   5069   else
   5070   {
   5071     bool itc_added;
   5072     /* accept only, have one thread per connection */
   5073     itc_added = false;
   5074     if (MHD_ITC_IS_VALID_ (daemon->itc))
   5075     {
   5076       itc_added = MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
   5077                                       &rs,
   5078                                       &maxsock,
   5079                                       (int) FD_SETSIZE);
   5080       if (! itc_added)
   5081       {
   5082 #ifdef HAVE_MESSAGES
   5083         MHD_DLOG (daemon, _ ("Could not add control inter-thread " \
   5084                              "communication channel FD to fdset.\n"));
   5085 #endif
   5086         err_state = MHD_YES;
   5087       }
   5088     }
   5089     if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_fd)) &&
   5090          (! daemon->was_quiesced) )
   5091     {
   5092       /* Stop listening if we are at the configured connection limit */
   5093       /* If we're at the connection limit, no point in really
   5094          accepting new connections; however, make sure we do not miss
   5095          the shutdown OR the termination of an existing connection; so
   5096          only do this optimisation if we have a signaling ITC in
   5097          place. */
   5098       if (! itc_added ||
   5099           ((daemon->connections < daemon->connection_limit) &&
   5100            ! daemon->at_limit))
   5101       {
   5102         if (! MHD_add_to_fd_set_ (ls,
   5103                                   &rs,
   5104                                   &maxsock,
   5105                                   (int) FD_SETSIZE))
   5106         {
   5107 #ifdef HAVE_MESSAGES
   5108           MHD_DLOG (daemon,
   5109                     _ ("Could not add listen socket to fdset.\n"));
   5110 #endif
   5111           err_state = MHD_YES;
   5112         }
   5113       }
   5114     }
   5115   }
   5116 
   5117   if (MHD_NO != err_state)
   5118     millisec = 0;
   5119   if (0 == millisec)
   5120   {
   5121     timeout.tv_usec = 0;
   5122     timeout.tv_sec = 0;
   5123     tv = &timeout;
   5124   }
   5125   else
   5126   {
   5127     uint64_t mhd_tmo;
   5128     uint64_t select_tmo;
   5129 
   5130     if ( (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon)) &&
   5131          (MHD_NO != MHD_get_timeout64 (daemon, &mhd_tmo)) )
   5132     {
   5133       if ( (0 < millisec) &&
   5134            (mhd_tmo > (uint64_t) millisec) )
   5135         select_tmo = (uint64_t) millisec;
   5136       else
   5137         select_tmo = mhd_tmo;
   5138       tv = &timeout; /* have timeout value */
   5139     }
   5140     else if (0 < millisec)
   5141     {
   5142       select_tmo = (uint64_t) millisec;
   5143       tv = &timeout; /* have timeout value */
   5144     }
   5145     else
   5146     {
   5147       select_tmo = 0; /* Not actually used, silent compiler warning */
   5148       tv = NULL;
   5149     }
   5150 
   5151     if (NULL != tv)
   5152     { /* have timeout value */
   5153 #if (SIZEOF_UINT64_T - 2) >= SIZEOF_STRUCT_TIMEVAL_TV_SEC
   5154       if (select_tmo / 1000 > TIMEVAL_TV_SEC_MAX)
   5155         timeout.tv_sec = TIMEVAL_TV_SEC_MAX;
   5156       else
   5157 #endif /* (SIZEOF_UINT64_T - 2) >= SIZEOF_STRUCT_TIMEVAL_TV_SEC */
   5158       timeout.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE) (select_tmo / 1000);
   5159 
   5160       timeout.tv_usec = ((uint16_t) (select_tmo % 1000)) * ((int32_t) 1000);
   5161     }
   5162   }
   5163   num_ready = MHD_SYS_select_ (maxsock + 1,
   5164                                &rs,
   5165                                &ws,
   5166                                &es,
   5167                                tv);
   5168   if (daemon->shutdown)
   5169     return MHD_NO;
   5170   if (num_ready < 0)
   5171   {
   5172     const int err = MHD_socket_get_error_ ();
   5173     if (MHD_SCKT_ERR_IS_EINTR_ (err))
   5174       return (MHD_NO == err_state) ? MHD_YES : MHD_NO;
   5175 #ifdef HAVE_MESSAGES
   5176     MHD_DLOG (daemon,
   5177               _ ("select failed: %s\n"),
   5178               MHD_socket_strerr_ (err));
   5179 #endif
   5180     return MHD_NO;
   5181   }
   5182   if (MHD_NO != internal_run_from_select (daemon,
   5183                                           &rs,
   5184                                           &ws,
   5185                                           &es,
   5186                                           (int) FD_SETSIZE))
   5187     return (MHD_NO == err_state) ? MHD_YES : MHD_NO;
   5188   return MHD_NO;
   5189 }
   5190 
   5191 
   5192 #ifdef HAVE_POLL
   5193 /**
   5194  * Process all of our connections and possibly the server
   5195  * socket using poll().
   5196  *
   5197  * @param daemon daemon to run poll loop for
   5198  * @param millisec the maximum time in milliseconds to wait for events,
   5199  *                 set to '0' for non-blocking processing,
   5200  *                 set to '-1' to wait indefinitely.
   5201  * @return #MHD_NO on serious errors, #MHD_YES on success
   5202  */
   5203 static enum MHD_Result
   5204 MHD_poll_all (struct MHD_Daemon *daemon,
   5205               int32_t millisec)
   5206 {
   5207   unsigned int num_connections;
   5208   struct MHD_Connection *pos;
   5209   struct MHD_Connection *prev;
   5210 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5211   struct MHD_UpgradeResponseHandle *urh;
   5212   struct MHD_UpgradeResponseHandle *urhn;
   5213 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5214 
   5215   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   5216               (MHD_thread_handle_ID_is_valid_ID_ (daemon->tid)));
   5217   mhd_assert ((0 != (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   5218               (! MHD_thread_handle_ID_is_valid_ID_ (daemon->tid)));
   5219   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   5220               (MHD_thread_handle_ID_is_current_thread_ (daemon->tid)));
   5221 
   5222   if ( (0 != (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME)) &&
   5223        (MHD_NO != resume_suspended_connections (daemon)) )
   5224     millisec = 0;
   5225 
   5226   /* count number of connections and thus determine poll set size */
   5227   num_connections = 0;
   5228   for (pos = daemon->connections_head; NULL != pos; pos = pos->next)
   5229     num_connections++;
   5230 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5231   for (urh = daemon->urh_head; NULL != urh; urh = urh->next)
   5232     num_connections += 2;
   5233 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5234   {
   5235     unsigned int i;
   5236     int timeout;
   5237     unsigned int poll_server;
   5238     int poll_listen;
   5239     int poll_itc_idx;
   5240     struct pollfd *p;
   5241     MHD_socket ls;
   5242 
   5243     p = MHD_calloc_ ((2 + (size_t) num_connections),
   5244                      sizeof (struct pollfd));
   5245     if (NULL == p)
   5246     {
   5247 #ifdef HAVE_MESSAGES
   5248       MHD_DLOG (daemon,
   5249                 _ ("Error allocating memory: %s\n"),
   5250                 MHD_strerror_ (errno));
   5251 #endif
   5252       return MHD_NO;
   5253     }
   5254     poll_server = 0;
   5255     poll_listen = -1;
   5256     if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_fd)) &&
   5257          (! daemon->was_quiesced) &&
   5258          (daemon->connections < daemon->connection_limit) &&
   5259          (! daemon->at_limit) )
   5260     {
   5261       /* only listen if we are not at the connection limit */
   5262       p[poll_server].fd = ls;
   5263       p[poll_server].events = POLLIN;
   5264       p[poll_server].revents = 0;
   5265       poll_listen = (int) poll_server;
   5266       poll_server++;
   5267     }
   5268     poll_itc_idx = -1;
   5269     if (MHD_ITC_IS_VALID_ (daemon->itc))
   5270     {
   5271       p[poll_server].fd = MHD_itc_r_fd_ (daemon->itc);
   5272       p[poll_server].events = POLLIN;
   5273       p[poll_server].revents = 0;
   5274       poll_itc_idx = (int) poll_server;
   5275       poll_server++;
   5276     }
   5277 
   5278     timeout = get_timeout_millisec_int (daemon, millisec);
   5279 
   5280     i = 0;
   5281     for (pos = daemon->connections_tail; NULL != pos; pos = pos->prev)
   5282     {
   5283       p[poll_server + i].fd = pos->socket_fd;
   5284       switch (pos->event_loop_info)
   5285       {
   5286       case MHD_EVENT_LOOP_INFO_READ:
   5287       case MHD_EVENT_LOOP_INFO_PROCESS_READ:
   5288         p[poll_server + i].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
   5289         break;
   5290       case MHD_EVENT_LOOP_INFO_WRITE:
   5291         p[poll_server + i].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
   5292         break;
   5293       case MHD_EVENT_LOOP_INFO_PROCESS:
   5294         p[poll_server + i].events |=  MHD_POLL_EVENTS_ERR_DISC;
   5295         break;
   5296       case MHD_EVENT_LOOP_INFO_CLEANUP:
   5297         timeout = 0; /* clean up "pos" immediately */
   5298         break;
   5299       }
   5300       i++;
   5301     }
   5302 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5303     for (urh = daemon->urh_tail; NULL != urh; urh = urh->prev)
   5304     {
   5305       urh_to_pollfd (urh, &(p[poll_server + i]));
   5306       i += 2;
   5307     }
   5308 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5309     if (0 == poll_server + num_connections)
   5310     {
   5311       free (p);
   5312       return MHD_YES;
   5313     }
   5314     if (MHD_sys_poll_ (p,
   5315                        poll_server + num_connections,
   5316                        timeout) < 0)
   5317     {
   5318       const int err = MHD_socket_get_error_ ();
   5319       if (MHD_SCKT_ERR_IS_EINTR_ (err))
   5320       {
   5321         free (p);
   5322         return MHD_YES;
   5323       }
   5324 #ifdef HAVE_MESSAGES
   5325       MHD_DLOG (daemon,
   5326                 _ ("poll failed: %s\n"),
   5327                 MHD_socket_strerr_ (err));
   5328 #endif
   5329       free (p);
   5330       return MHD_NO;
   5331     }
   5332 
   5333     /* handle ITC FD */
   5334     /* do it before any other processing so
   5335        new signals will be processed in next loop */
   5336     if ( (-1 != poll_itc_idx) &&
   5337          (0 != (p[poll_itc_idx].revents & POLLIN)) )
   5338       MHD_itc_clear_ (daemon->itc);
   5339 
   5340     /* handle shutdown */
   5341     if (daemon->shutdown)
   5342     {
   5343       free (p);
   5344       return MHD_NO;
   5345     }
   5346 
   5347     /* Process externally added connection if any */
   5348     if (daemon->have_new)
   5349       new_connections_list_process_ (daemon);
   5350 
   5351     /* handle 'listen' FD */
   5352     if ( (-1 != poll_listen) &&
   5353          (0 != (p[poll_listen].revents & POLLIN)) )
   5354       (void) MHD_accept_connection (daemon);
   5355 
   5356     /* Reset. New value will be set when connections are processed. */
   5357     daemon->data_already_pending = false;
   5358 
   5359     i = 0;
   5360     prev = daemon->connections_tail;
   5361     while (NULL != (pos = prev))
   5362     {
   5363       prev = pos->prev;
   5364       /* first, sanity checks */
   5365       if (i >= num_connections)
   5366         break;     /* connection list changed somehow, retry later ... */
   5367       if (p[poll_server + i].fd != pos->socket_fd)
   5368         continue;  /* fd mismatch, something else happened, retry later ... */
   5369       call_handlers (pos,
   5370                      0 != (p[poll_server + i].revents & POLLIN),
   5371                      0 != (p[poll_server + i].revents & POLLOUT),
   5372                      0 != (p[poll_server + i].revents
   5373                            & MHD_POLL_REVENTS_ERR_DISC));
   5374       i++;
   5375     }
   5376 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5377     for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
   5378     {
   5379       if (i >= num_connections)
   5380         break;   /* connection list changed somehow, retry later ... */
   5381 
   5382       /* Get next connection here as connection can be removed
   5383        * from 'daemon->urh_head' list. */
   5384       urhn = urh->prev;
   5385       /* Check for fd mismatch. FIXME: required for safety? */
   5386       if ((p[poll_server + i].fd != urh->connection->socket_fd) ||
   5387           (p[poll_server + i + 1].fd != urh->mhd.socket))
   5388         break;
   5389       urh_from_pollfd (urh,
   5390                        &p[poll_server + i]);
   5391       i += 2;
   5392       process_urh (urh);
   5393       /* Finished forwarding? */
   5394       if ( (0 == urh->in_buffer_size) &&
   5395            (0 == urh->out_buffer_size) &&
   5396            (0 == urh->in_buffer_used) &&
   5397            (0 == urh->out_buffer_used) )
   5398       {
   5399         /* MHD_connection_finish_forward_() will remove connection from
   5400          * 'daemon->urh_head' list. */
   5401         MHD_connection_finish_forward_ (urh->connection);
   5402         urh->clean_ready = true;
   5403         /* If 'urh->was_closed' already was set to true, connection will be
   5404          * moved immediately to cleanup list. Otherwise connection
   5405          * will stay in suspended list until 'urh' will be marked
   5406          * with 'was_closed' by application. */
   5407         MHD_resume_connection (urh->connection);
   5408       }
   5409     }
   5410 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5411 
   5412     free (p);
   5413   }
   5414   return MHD_YES;
   5415 }
   5416 
   5417 
   5418 /**
   5419  * Process only the listen socket using poll().
   5420  *
   5421  * @param daemon daemon to run poll loop for
   5422  * @param may_block #MHD_YES if blocking, #MHD_NO if non-blocking
   5423  * @return #MHD_NO on serious errors, #MHD_YES on success
   5424  */
   5425 static enum MHD_Result
   5426 MHD_poll_listen_socket (struct MHD_Daemon *daemon,
   5427                         int may_block)
   5428 {
   5429   struct pollfd p[2];
   5430   int timeout;
   5431   unsigned int poll_count;
   5432   int poll_listen;
   5433   int poll_itc_idx;
   5434   MHD_socket ls;
   5435 
   5436   mhd_assert (MHD_thread_handle_ID_is_valid_ID_ (daemon->tid));
   5437   mhd_assert (MHD_thread_handle_ID_is_current_thread_ (daemon->tid));
   5438 
   5439   memset (&p,
   5440           0,
   5441           sizeof (p));
   5442   poll_count = 0;
   5443   poll_listen = -1;
   5444   poll_itc_idx = -1;
   5445   if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_fd)) &&
   5446        (! daemon->was_quiesced) )
   5447 
   5448   {
   5449     p[poll_count].fd = ls;
   5450     p[poll_count].events = POLLIN;
   5451     p[poll_count].revents = 0;
   5452     poll_listen = (int) poll_count;
   5453     poll_count++;
   5454   }
   5455   if (MHD_ITC_IS_VALID_ (daemon->itc))
   5456   {
   5457     p[poll_count].fd = MHD_itc_r_fd_ (daemon->itc);
   5458     p[poll_count].events = POLLIN;
   5459     p[poll_count].revents = 0;
   5460     poll_itc_idx = (int) poll_count;
   5461     poll_count++;
   5462   }
   5463 
   5464   if (0 != (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME))
   5465     (void) resume_suspended_connections (daemon);
   5466 
   5467   if (MHD_NO == may_block)
   5468     timeout = 0;
   5469   else
   5470     timeout = -1;
   5471   if (0 == poll_count)
   5472     return MHD_YES;
   5473   if (MHD_sys_poll_ (p,
   5474                      poll_count,
   5475                      timeout) < 0)
   5476   {
   5477     const int err = MHD_socket_get_error_ ();
   5478 
   5479     if (MHD_SCKT_ERR_IS_EINTR_ (err))
   5480       return MHD_YES;
   5481 #ifdef HAVE_MESSAGES
   5482     MHD_DLOG (daemon,
   5483               _ ("poll failed: %s\n"),
   5484               MHD_socket_strerr_ (err));
   5485 #endif
   5486     return MHD_NO;
   5487   }
   5488   if ( (0 <= poll_itc_idx) &&
   5489        (0 != (p[poll_itc_idx].revents & POLLIN)) )
   5490     MHD_itc_clear_ (daemon->itc);
   5491 
   5492   /* handle shutdown */
   5493   if (daemon->shutdown)
   5494     return MHD_NO;
   5495 
   5496   /* Process externally added connection if any */
   5497   if (daemon->have_new)
   5498     new_connections_list_process_ (daemon);
   5499 
   5500   if ( (0 <= poll_listen) &&
   5501        (0 != (p[poll_listen].revents & POLLIN)) )
   5502     (void) MHD_accept_connection (daemon);
   5503   return MHD_YES;
   5504 }
   5505 
   5506 
   5507 #endif
   5508 
   5509 #ifdef HAVE_POLL
   5510 
   5511 /**
   5512  * Do poll()-based processing.
   5513  *
   5514  * @param daemon daemon to run poll()-loop for
   5515  * @param may_block #MHD_YES if blocking, #MHD_NO if non-blocking
   5516  * @return #MHD_NO on serious errors, #MHD_YES on success
   5517  */
   5518 static enum MHD_Result
   5519 MHD_poll (struct MHD_Daemon *daemon,
   5520           int may_block)
   5521 {
   5522   if (! MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   5523     return MHD_poll_all (daemon,
   5524                          may_block ? -1 : 0);
   5525   return MHD_poll_listen_socket (daemon,
   5526                                  may_block);
   5527 }
   5528 
   5529 
   5530 #endif /* HAVE_POLL */
   5531 
   5532 
   5533 #ifdef EPOLL_SUPPORT
   5534 
   5535 /**
   5536  * How many events to we process at most per epoll() call?  Trade-off
   5537  * between required stack-size and number of system calls we have to
   5538  * make; 128 should be way enough to avoid more than one system call
   5539  * for most scenarios, and still be moderate in stack size
   5540  * consumption.  Embedded systems might want to choose a smaller value
   5541  * --- but why use epoll() on such a system in the first place?
   5542  */
   5543 #define MAX_EVENTS 128
   5544 
   5545 
   5546 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5547 
   5548 /**
   5549  * Checks whether @a urh has some data to process.
   5550  *
   5551  * @param urh upgrade handler to analyse
   5552  * @return 'true' if @a urh has some data to process,
   5553  *         'false' otherwise
   5554  */
   5555 static bool
   5556 is_urh_ready (struct MHD_UpgradeResponseHandle *const urh)
   5557 {
   5558   const struct MHD_Connection *const connection = urh->connection;
   5559 
   5560   if ( (0 == urh->in_buffer_size) &&
   5561        (0 == urh->out_buffer_size) &&
   5562        (0 == urh->in_buffer_used) &&
   5563        (0 == urh->out_buffer_used) )
   5564     return false;
   5565   if (connection->daemon->shutdown)
   5566     return true;
   5567   if ( ( (0 != ((MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_ERROR)
   5568                 & urh->app.celi)) ||
   5569          (connection->tls_read_ready) ) &&
   5570        (urh->in_buffer_used < urh->in_buffer_size) )
   5571     return true;
   5572   if ( ( (0 != ((MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_ERROR)
   5573                 & urh->mhd.celi)) ||
   5574          urh->was_closed) &&
   5575        (urh->out_buffer_used < urh->out_buffer_size) )
   5576     return true;
   5577   if ( (0 != (MHD_EPOLL_STATE_WRITE_READY & urh->app.celi)) &&
   5578        (urh->out_buffer_used > 0) )
   5579     return true;
   5580   if ( (0 != (MHD_EPOLL_STATE_WRITE_READY & urh->mhd.celi)) &&
   5581        (urh->in_buffer_used > 0) )
   5582     return true;
   5583   return false;
   5584 }
   5585 
   5586 
   5587 /**
   5588  * Do epoll()-based processing for TLS connections that have been
   5589  * upgraded.  This requires a separate epoll() invocation as we
   5590  * cannot use the `struct MHD_Connection` data structures for
   5591  * the `union epoll_data` in this case.
   5592  * @remark To be called only from thread that process
   5593  * daemon's select()/poll()/etc.
   5594  */
   5595 static enum MHD_Result
   5596 run_epoll_for_upgrade (struct MHD_Daemon *daemon)
   5597 {
   5598   struct epoll_event events[MAX_EVENTS];
   5599   int num_events;
   5600   struct MHD_UpgradeResponseHandle *pos;
   5601   struct MHD_UpgradeResponseHandle *prev;
   5602 
   5603 #ifdef MHD_USE_THREADS
   5604   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   5605                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   5606 #endif /* MHD_USE_THREADS */
   5607 
   5608   num_events = MAX_EVENTS;
   5609   while (0 != num_events)
   5610   {
   5611     unsigned int i;
   5612     /* update event masks */
   5613     num_events = epoll_wait (daemon->epoll_upgrade_fd,
   5614                              events,
   5615                              MAX_EVENTS,
   5616                              0);
   5617     if (-1 == num_events)
   5618     {
   5619       const int err = MHD_socket_get_error_ ();
   5620 
   5621       if (MHD_SCKT_ERR_IS_EINTR_ (err))
   5622         return MHD_YES;
   5623 #ifdef HAVE_MESSAGES
   5624       MHD_DLOG (daemon,
   5625                 _ ("Call to epoll_wait failed: %s\n"),
   5626                 MHD_socket_strerr_ (err));
   5627 #endif
   5628       return MHD_NO;
   5629     }
   5630     for (i = 0; i < (unsigned int) num_events; i++)
   5631     {
   5632       struct UpgradeEpollHandle *const ueh = events[i].data.ptr;
   5633       struct MHD_UpgradeResponseHandle *const urh = ueh->urh;
   5634       bool new_err_state = false;
   5635 
   5636       if (urh->clean_ready)
   5637         continue;
   5638 
   5639       /* Update ueh state based on what is ready according to epoll() */
   5640       if (0 != (events[i].events & EPOLLIN))
   5641       {
   5642         ueh->celi |= MHD_EPOLL_STATE_READ_READY;
   5643       }
   5644       if (0 != (events[i].events & EPOLLOUT))
   5645       {
   5646         ueh->celi |= MHD_EPOLL_STATE_WRITE_READY;
   5647       }
   5648       if (0 != (events[i].events & EPOLLHUP))
   5649       {
   5650         ueh->celi |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
   5651       }
   5652 
   5653       if ( (0 == (ueh->celi & MHD_EPOLL_STATE_ERROR)) &&
   5654            (0 != (events[i].events & (EPOLLERR | EPOLLPRI))) )
   5655       {
   5656         /* Process new error state only one time and avoid continuously
   5657          * marking this connection as 'ready'. */
   5658         ueh->celi |= MHD_EPOLL_STATE_ERROR;
   5659         new_err_state = true;
   5660       }
   5661       if (! urh->in_eready_list)
   5662       {
   5663         if (new_err_state ||
   5664             is_urh_ready (urh))
   5665         {
   5666           EDLL_insert (daemon->eready_urh_head,
   5667                        daemon->eready_urh_tail,
   5668                        urh);
   5669           urh->in_eready_list = true;
   5670         }
   5671       }
   5672     }
   5673   }
   5674   prev = daemon->eready_urh_tail;
   5675   while (NULL != (pos = prev))
   5676   {
   5677     prev = pos->prevE;
   5678     process_urh (pos);
   5679     if (! is_urh_ready (pos))
   5680     {
   5681       EDLL_remove (daemon->eready_urh_head,
   5682                    daemon->eready_urh_tail,
   5683                    pos);
   5684       pos->in_eready_list = false;
   5685     }
   5686     /* Finished forwarding? */
   5687     if ( (0 == pos->in_buffer_size) &&
   5688          (0 == pos->out_buffer_size) &&
   5689          (0 == pos->in_buffer_used) &&
   5690          (0 == pos->out_buffer_used) )
   5691     {
   5692       MHD_connection_finish_forward_ (pos->connection);
   5693       pos->clean_ready = true;
   5694       /* If 'pos->was_closed' already was set to true, connection
   5695        * will be moved immediately to cleanup list. Otherwise
   5696        * connection will stay in suspended list until 'pos' will
   5697        * be marked with 'was_closed' by application. */
   5698       MHD_resume_connection (pos->connection);
   5699     }
   5700   }
   5701 
   5702   return MHD_YES;
   5703 }
   5704 
   5705 
   5706 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5707 
   5708 
   5709 /**
   5710  * Pointer-marker to distinguish ITC slot in epoll sets.
   5711  */
   5712 static const char *const epoll_itc_marker = "itc_marker";
   5713 
   5714 
   5715 /**
   5716  * Do epoll()-based processing.
   5717  *
   5718  * @param daemon daemon to run poll loop for
   5719  * @param millisec the maximum time in milliseconds to wait for events,
   5720  *                 set to '0' for non-blocking processing,
   5721  *                 set to '-1' to wait indefinitely.
   5722  * @return #MHD_NO on serious errors, #MHD_YES on success
   5723  */
   5724 static enum MHD_Result
   5725 MHD_epoll (struct MHD_Daemon *daemon,
   5726            int32_t millisec)
   5727 {
   5728 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5729   static const char *const upgrade_marker = "upgrade_ptr";
   5730 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5731   struct MHD_Connection *pos;
   5732   struct MHD_Connection *prev;
   5733   struct epoll_event events[MAX_EVENTS];
   5734   struct epoll_event event;
   5735   int timeout_ms;
   5736   int num_events;
   5737   unsigned int i;
   5738   MHD_socket ls;
   5739 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5740   bool run_upgraded = false;
   5741 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5742   bool need_to_accept;
   5743 
   5744   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   5745               (MHD_thread_handle_ID_is_valid_ID_ (daemon->tid)));
   5746   mhd_assert ((0 != (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   5747               (! MHD_thread_handle_ID_is_valid_ID_ (daemon->tid)));
   5748   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   5749               (MHD_thread_handle_ID_is_current_thread_ (daemon->tid)));
   5750 
   5751   if (-1 == daemon->epoll_fd)
   5752     return MHD_NO; /* we're down! */
   5753   if (daemon->shutdown)
   5754     return MHD_NO;
   5755   /* 'listen_socket_in_epoll', 'was_quiesced' and the epoll set itself
   5756      are shared with MHD_quiesce_daemon(), which runs on the
   5757      application's thread.  Testing them and acting on the result has to
   5758      be one atomic step. */
   5759 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   5760   MHD_mutex_lock_chk_ (&daemon->epoll_listen_mutex);
   5761 #endif
   5762   if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_fd)) &&
   5763        (! daemon->was_quiesced) &&
   5764        (daemon->connections < daemon->connection_limit) &&
   5765        (! daemon->listen_socket_in_epoll) &&
   5766        (! daemon->at_limit) )
   5767   {
   5768     event.events = EPOLLIN | EPOLLRDHUP;
   5769     event.data.ptr = daemon;
   5770     if (0 != epoll_ctl (daemon->epoll_fd,
   5771                         EPOLL_CTL_ADD,
   5772                         ls,
   5773                         &event))
   5774     {
   5775 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   5776       MHD_mutex_unlock_chk_ (&daemon->epoll_listen_mutex);
   5777 #endif
   5778 #ifdef HAVE_MESSAGES
   5779       MHD_DLOG (daemon,
   5780                 _ ("Call to epoll_ctl failed: %s\n"),
   5781                 MHD_socket_last_strerr_ ());
   5782 #endif
   5783       return MHD_NO;
   5784     }
   5785     daemon->listen_socket_in_epoll = true;
   5786   }
   5787   if ( (daemon->was_quiesced) &&
   5788        (daemon->listen_socket_in_epoll) )
   5789   {
   5790     if (0 != epoll_ctl (daemon->epoll_fd,
   5791                         EPOLL_CTL_DEL,
   5792                         ls,
   5793                         NULL))
   5794       MHD_PANIC ("Failed to remove listen FD from epoll set.\n");
   5795     daemon->listen_socket_in_epoll = false;
   5796   }
   5797 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   5798   MHD_mutex_unlock_chk_ (&daemon->epoll_listen_mutex);
   5799 #endif
   5800 
   5801 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5802   if ( ( (! daemon->upgrade_fd_in_epoll) &&
   5803          (-1 != daemon->epoll_upgrade_fd) ) )
   5804   {
   5805     event.events = EPOLLIN | EPOLLOUT | EPOLLRDHUP;
   5806     event.data.ptr = _MHD_DROP_CONST (upgrade_marker);
   5807     if (0 != epoll_ctl (daemon->epoll_fd,
   5808                         EPOLL_CTL_ADD,
   5809                         daemon->epoll_upgrade_fd,
   5810                         &event))
   5811     {
   5812 #ifdef HAVE_MESSAGES
   5813       MHD_DLOG (daemon,
   5814                 _ ("Call to epoll_ctl failed: %s\n"),
   5815                 MHD_socket_last_strerr_ ());
   5816 #endif
   5817       return MHD_NO;
   5818     }
   5819     daemon->upgrade_fd_in_epoll = true;
   5820   }
   5821 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5822 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   5823   MHD_mutex_lock_chk_ (&daemon->epoll_listen_mutex);
   5824 #endif
   5825   if ( (daemon->listen_socket_in_epoll) &&
   5826        ( (daemon->connections == daemon->connection_limit) ||
   5827          (daemon->at_limit) ||
   5828          (daemon->was_quiesced) ) )
   5829   {
   5830     /* we're at the connection limit, disable listen socket
   5831  for event loop for now */
   5832     if (0 != epoll_ctl (daemon->epoll_fd,
   5833                         EPOLL_CTL_DEL,
   5834                         ls,
   5835                         NULL))
   5836       MHD_PANIC (_ ("Failed to remove listen FD from epoll set.\n"));
   5837     daemon->listen_socket_in_epoll = false;
   5838   }
   5839 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   5840   MHD_mutex_unlock_chk_ (&daemon->epoll_listen_mutex);
   5841 #endif
   5842 
   5843   if ( (0 != (daemon->options & MHD_TEST_ALLOW_SUSPEND_RESUME)) &&
   5844        (MHD_NO != resume_suspended_connections (daemon)) )
   5845     millisec = 0;
   5846 
   5847   timeout_ms = get_timeout_millisec_int (daemon,
   5848                                          millisec);
   5849 
   5850   /* Reset. New value will be set when connections are processed. */
   5851   /* Note: Used mostly for uniformity here as same situation is
   5852    * signaled in epoll mode by non-empty eready DLL. */
   5853   daemon->data_already_pending = false;
   5854 
   5855   need_to_accept = false;
   5856   /* drain 'epoll' event queue; need to iterate as we get at most
   5857      MAX_EVENTS in one system call here; in practice this should
   5858      pretty much mean only one round, but better an extra loop here
   5859      than unfair behavior... */
   5860   num_events = MAX_EVENTS;
   5861   while (MAX_EVENTS == num_events)
   5862   {
   5863     /* update event masks */
   5864     num_events = epoll_wait (daemon->epoll_fd,
   5865                              events,
   5866                              MAX_EVENTS,
   5867                              timeout_ms);
   5868     /* A full batch may have been the last of the pending events: the next
   5869        call only drains what is left, it must not wait.  With edge-triggered
   5870        connections nothing new arrives until they are processed, so waiting
   5871        here would stall every connection until the timeout. */
   5872     timeout_ms = 0;
   5873     if (-1 == num_events)
   5874     {
   5875       const int err = MHD_socket_get_error_ ();
   5876       if (MHD_SCKT_ERR_IS_EINTR_ (err))
   5877         return MHD_YES;
   5878 #ifdef HAVE_MESSAGES
   5879       MHD_DLOG (daemon,
   5880                 _ ("Call to epoll_wait failed: %s\n"),
   5881                 MHD_socket_strerr_ (err));
   5882 #endif
   5883       return MHD_NO;
   5884     }
   5885     for (i = 0; i < (unsigned int) num_events; i++)
   5886     {
   5887       /* First, check for the values of `ptr` that would indicate
   5888          that this event is not about a normal connection. */
   5889       if (NULL == events[i].data.ptr)
   5890         continue;     /* shutdown signal! */
   5891 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   5892       if (upgrade_marker == events[i].data.ptr)
   5893       {
   5894         /* activity on an upgraded connection, we process
   5895            those in a separate epoll() */
   5896         run_upgraded = true;
   5897         continue;
   5898       }
   5899 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   5900       if (epoll_itc_marker == events[i].data.ptr)
   5901       {
   5902         /* It's OK to clear ITC here as all external
   5903            conditions will be processed later. */
   5904         MHD_itc_clear_ (daemon->itc);
   5905         continue;
   5906       }
   5907       if (daemon == events[i].data.ptr)
   5908       {
   5909         /* Check for error conditions on listen socket. */
   5910         /* FIXME: Initiate MHD_quiesce_daemon() to prevent busy waiting? */
   5911         if (0 == (events[i].events & (EPOLLERR | EPOLLHUP)))
   5912           need_to_accept = true;
   5913         continue;
   5914       }
   5915       /* this is an event relating to a 'normal' connection,
   5916          remember the event and if appropriate mark the
   5917          connection as 'eready'. */
   5918       pos = events[i].data.ptr;
   5919       /* normal processing: update read/write data */
   5920       if (0 != (events[i].events & (EPOLLPRI | EPOLLERR | EPOLLHUP)))
   5921       {
   5922         pos->epoll_state |= MHD_EPOLL_STATE_ERROR;
   5923         if (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
   5924         {
   5925           EDLL_insert (daemon->eready_head,
   5926                        daemon->eready_tail,
   5927                        pos);
   5928           pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
   5929         }
   5930       }
   5931       else
   5932       {
   5933         if (0 != (events[i].events & EPOLLIN))
   5934         {
   5935           pos->epoll_state |= MHD_EPOLL_STATE_READ_READY;
   5936           if ( ( (0 != (MHD_EVENT_LOOP_INFO_READ & pos->event_loop_info)) ||
   5937                  (pos->read_buffer_size > pos->read_buffer_offset) ) &&
   5938                (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
   5939           {
   5940             EDLL_insert (daemon->eready_head,
   5941                          daemon->eready_tail,
   5942                          pos);
   5943             pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
   5944           }
   5945         }
   5946         if (0 != (events[i].events & EPOLLOUT))
   5947         {
   5948           pos->epoll_state |= MHD_EPOLL_STATE_WRITE_READY;
   5949           if ( (MHD_EVENT_LOOP_INFO_WRITE == pos->event_loop_info) &&
   5950                (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
   5951           {
   5952             EDLL_insert (daemon->eready_head,
   5953                          daemon->eready_tail,
   5954                          pos);
   5955             pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
   5956           }
   5957         }
   5958       }
   5959     }
   5960   }
   5961 
   5962   /* Process externally added connection if any */
   5963   if (daemon->have_new)
   5964     new_connections_list_process_ (daemon);
   5965 
   5966   if (need_to_accept)
   5967   {
   5968     unsigned int series_length = 0;
   5969 
   5970     /* Run 'accept' until it fails or daemon at limit of connections.
   5971      * Do not accept more then 10 connections at once. The rest will
   5972      * be accepted on next turn (level trigger is used for listen
   5973      * socket). */
   5974     while ( (MHD_NO != MHD_accept_connection (daemon)) &&
   5975             (series_length < 10) &&
   5976             (daemon->connections < daemon->connection_limit) &&
   5977             (! daemon->at_limit) )
   5978       series_length++;
   5979   }
   5980 
   5981   /* Handle timed-out connections; we need to do this here
   5982      as the epoll mechanism won't call the 'MHD_connection_handle_idle()' on everything,
   5983      as the other event loops do.  As timeouts do not get an explicit
   5984      event, we need to find those connections that might have timed out
   5985      here.
   5986 
   5987      Connections with custom timeouts must all be looked at, as we
   5988      do not bother to sort that (presumably very short) list. */
   5989   prev = daemon->manual_timeout_tail;
   5990   while (NULL != (pos = prev))
   5991   {
   5992     prev = pos->prevX;
   5993     MHD_connection_handle_idle (pos);
   5994   }
   5995   /* Connections with the default timeout are sorted by prepending
   5996      them to the head of the list whenever we touch the connection;
   5997      thus it suffices to iterate from the tail until the first
   5998      connection is NOT timed out */
   5999   prev = daemon->normal_timeout_tail;
   6000   while (NULL != (pos = prev))
   6001   {
   6002     prev = pos->prevX;
   6003     MHD_connection_handle_idle (pos);
   6004     if (MHD_CONNECTION_CLOSED != pos->state)
   6005       break; /* sorted by timeout, no need to visit the rest! */
   6006   }
   6007 
   6008 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   6009   if (run_upgraded || (NULL != daemon->eready_urh_head))
   6010     run_epoll_for_upgrade (daemon);
   6011 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   6012 
   6013   /* process events for connections */
   6014   prev = daemon->eready_tail;
   6015   while (NULL != (pos = prev))
   6016   {
   6017     prev = pos->prevE;
   6018     call_handlers (pos,
   6019                    0 != (pos->epoll_state & MHD_EPOLL_STATE_READ_READY),
   6020                    0 != (pos->epoll_state & MHD_EPOLL_STATE_WRITE_READY),
   6021                    0 != (pos->epoll_state & MHD_EPOLL_STATE_ERROR));
   6022     if (MHD_EPOLL_STATE_IN_EREADY_EDLL ==
   6023         (pos->epoll_state & (MHD_EPOLL_STATE_SUSPENDED
   6024                              | MHD_EPOLL_STATE_IN_EREADY_EDLL)))
   6025     {
   6026       if ( ((MHD_EVENT_LOOP_INFO_READ == pos->event_loop_info) &&
   6027             (0 == (pos->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ||
   6028            ((MHD_EVENT_LOOP_INFO_WRITE == pos->event_loop_info) &&
   6029             (0 == (pos->epoll_state & MHD_EPOLL_STATE_WRITE_READY)) ) ||
   6030            (MHD_EVENT_LOOP_INFO_CLEANUP == pos->event_loop_info) )
   6031       {
   6032         EDLL_remove (daemon->eready_head,
   6033                      daemon->eready_tail,
   6034                      pos);
   6035         pos->epoll_state &=
   6036           ~((enum MHD_EpollState) MHD_EPOLL_STATE_IN_EREADY_EDLL);
   6037       }
   6038     }
   6039   }
   6040 
   6041   return MHD_YES;
   6042 }
   6043 
   6044 
   6045 #endif
   6046 
   6047 
   6048 /**
   6049  * Run webserver operations (without blocking unless in client callbacks).
   6050  *
   6051  * This method should be called by clients in combination with
   6052  * #MHD_get_fdset() (or #MHD_get_daemon_info() with MHD_DAEMON_INFO_EPOLL_FD
   6053  * if epoll is used) and #MHD_get_timeout() if the client-controlled
   6054  * connection polling method is used (i.e. daemon was started without
   6055  * #MHD_USE_INTERNAL_POLLING_THREAD flag).
   6056  *
   6057  * This function is a convenience method, which is useful if the
   6058  * fd_sets from #MHD_get_fdset were not directly passed to `select()`;
   6059  * with this function, MHD will internally do the appropriate `select()`
   6060  * call itself again.  While it is acceptable to call #MHD_run (if
   6061  * #MHD_USE_INTERNAL_POLLING_THREAD is not set) at any moment, you should
   6062  * call #MHD_run_from_select() if performance is important (as it saves an
   6063  * expensive call to `select()`).
   6064  *
   6065  * If #MHD_get_timeout() returned #MHD_YES, than this function must be called
   6066  * right after polling function returns regardless of detected activity on
   6067  * the daemon's FDs.
   6068  *
   6069  * @param daemon daemon to run
   6070  * @return #MHD_YES on success, #MHD_NO if this
   6071  *         daemon was not started with the right
   6072  *         options for this call.
   6073  * @ingroup event
   6074  */
   6075 _MHD_EXTERN enum MHD_Result
   6076 MHD_run (struct MHD_Daemon *daemon)
   6077 {
   6078   if ( (daemon->shutdown) ||
   6079        MHD_D_IS_USING_THREADS_ (daemon) )
   6080     return MHD_NO;
   6081 
   6082   (void) MHD_run_wait (daemon, 0);
   6083   return MHD_YES;
   6084 }
   6085 
   6086 
   6087 /**
   6088  * Run webserver operation with possible blocking.
   6089  *
   6090  * This function does the following: waits for any network event not more than
   6091  * specified number of milliseconds, processes all incoming and outgoing data,
   6092  * processes new connections, processes any timed-out connection, and does
   6093  * other things required to run webserver.
   6094  * Once all connections are processed, function returns.
   6095  *
   6096  * This function is useful for quick and simple (lazy) webserver implementation
   6097  * if application needs to run a single thread only and does not have any other
   6098  * network activity.
   6099  *
   6100  * This function calls MHD_get_timeout() internally and use returned value as
   6101  * maximum wait time if it less than value of @a millisec parameter.
   6102  *
   6103  * It is expected that the "external" socket polling function is not used in
   6104  * conjunction with this function unless the @a millisec is set to zero.
   6105  *
   6106  * @param daemon the daemon to run
   6107  * @param millisec the maximum time in milliseconds to wait for network and
   6108  *                 other events. Note: there is no guarantee that function
   6109  *                 blocks for the specified amount of time. The real processing
   6110  *                 time can be shorter (if some data or connection timeout
   6111  *                 comes earlier) or longer (if data processing requires more
   6112  *                 time, especially in user callbacks).
   6113  *                 If set to '0' then function does not block and processes
   6114  *                 only already available data (if any).
   6115  *                 If set to '-1' then function waits for events
   6116  *                 indefinitely (blocks until next network activity or
   6117  *                 connection timeout).
   6118  * @return #MHD_YES on success, #MHD_NO if this
   6119  *         daemon was not started with the right
   6120  *         options for this call or some serious
   6121  *         unrecoverable error occurs.
   6122  * @note Available since #MHD_VERSION 0x00097206
   6123  * @ingroup event
   6124  */
   6125 _MHD_EXTERN enum MHD_Result
   6126 MHD_run_wait (struct MHD_Daemon *daemon,
   6127               int32_t millisec)
   6128 {
   6129   enum MHD_Result res;
   6130   if ( (daemon->shutdown) ||
   6131        MHD_D_IS_USING_THREADS_ (daemon) )
   6132     return MHD_NO;
   6133 
   6134   mhd_assert (! MHD_thread_handle_ID_is_valid_handle_ (daemon->tid));
   6135 
   6136   if (0 > millisec)
   6137     millisec = -1;
   6138 #ifdef HAVE_POLL
   6139   if (MHD_D_IS_USING_POLL_ (daemon))
   6140   {
   6141     res = MHD_poll_all (daemon, millisec);
   6142     MHD_cleanup_connections (daemon);
   6143   }
   6144   else
   6145 #endif /* HAVE_POLL */
   6146 #ifdef EPOLL_SUPPORT
   6147   if (MHD_D_IS_USING_EPOLL_ (daemon))
   6148   {
   6149     res = MHD_epoll (daemon, millisec);
   6150     MHD_cleanup_connections (daemon);
   6151   }
   6152   else
   6153 #endif
   6154   if (1)
   6155   {
   6156     mhd_assert (MHD_D_IS_USING_SELECT_ (daemon));
   6157 #ifdef HAS_FD_SETSIZE_OVERRIDABLE
   6158 #ifdef HAVE_MESSAGES
   6159     if (daemon->fdset_size_set_by_app
   6160         && (((int) FD_SETSIZE) < daemon->fdset_size))
   6161     {
   6162       MHD_DLOG (daemon,
   6163                 _ ("MHD_run()/MHD_run_wait() called for daemon started with " \
   6164                    "MHD_OPTION_APP_FD_SETSIZE option (%d). " \
   6165                    "The library was compiled with smaller FD_SETSIZE (%d). " \
   6166                    "Some socket FDs may be not processed. " \
   6167                    "Use MHD_run_from_select2() instead of MHD_run() or " \
   6168                    "do not use MHD_OPTION_APP_FD_SETSIZE option.\n"),
   6169                 daemon->fdset_size, (int) FD_SETSIZE);
   6170     }
   6171 #endif /* HAVE_MESSAGES */
   6172 #endif /* HAS_FD_SETSIZE_OVERRIDABLE */
   6173 
   6174     res = MHD_select (daemon, millisec);
   6175     /* MHD_select does MHD_cleanup_connections already */
   6176   }
   6177   return res;
   6178 }
   6179 
   6180 
   6181 /**
   6182  * Close the given connection, remove it from all of its
   6183  * DLLs and move it into the cleanup queue.
   6184  * @remark To be called only from thread that
   6185  * process daemon's select()/poll()/etc.
   6186  *
   6187  * @param pos connection to move to cleanup
   6188  */
   6189 static void
   6190 close_connection (struct MHD_Connection *pos)
   6191 {
   6192   struct MHD_Daemon *daemon = pos->daemon;
   6193 
   6194 #ifdef MHD_USE_THREADS
   6195   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   6196                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   6197   mhd_assert (NULL == daemon->worker_pool);
   6198 #endif /* MHD_USE_THREADS */
   6199 
   6200   if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   6201   {
   6202     MHD_connection_mark_closed_ (pos);
   6203     return;   /* must let thread to do the rest */
   6204   }
   6205   MHD_connection_close_ (pos,
   6206                          MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN);
   6207 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6208   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   6209 #endif
   6210   mhd_assert (! pos->suspended);
   6211   mhd_assert (! pos->resuming);
   6212   if (pos->connection_timeout_ms == daemon->connection_timeout_ms)
   6213     XDLL_remove (daemon->normal_timeout_head,
   6214                  daemon->normal_timeout_tail,
   6215                  pos);
   6216   else
   6217     XDLL_remove (daemon->manual_timeout_head,
   6218                  daemon->manual_timeout_tail,
   6219                  pos);
   6220   DLL_remove (daemon->connections_head,
   6221               daemon->connections_tail,
   6222               pos);
   6223   DLL_insert (daemon->cleanup_head,
   6224               daemon->cleanup_tail,
   6225               pos);
   6226   daemon->data_already_pending = true;
   6227 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6228   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   6229 #endif
   6230 }
   6231 
   6232 
   6233 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6234 /**
   6235  * Thread that runs the polling loop until the daemon
   6236  * is explicitly shut down.
   6237  *
   6238  * @param cls `struct MHD_Deamon` to run select loop in a thread for
   6239  * @return always 0 (on shutdown)
   6240  */
   6241 static MHD_THRD_RTRN_TYPE_ MHD_THRD_CALL_SPEC_
   6242 MHD_polling_thread (void *cls)
   6243 {
   6244   struct MHD_Daemon *daemon = cls;
   6245 #ifdef HAVE_PTHREAD_SIGMASK
   6246   sigset_t s_mask;
   6247   int err;
   6248 #endif /* HAVE_PTHREAD_SIGMASK */
   6249 
   6250   MHD_thread_handle_ID_set_current_thread_ID_ (&(daemon->tid));
   6251 #ifdef HAVE_PTHREAD_SIGMASK
   6252   if ((0 == sigemptyset (&s_mask)) &&
   6253       (0 == sigaddset (&s_mask, SIGPIPE)))
   6254   {
   6255     err = pthread_sigmask (SIG_BLOCK, &s_mask, NULL);
   6256   }
   6257   else
   6258     err = errno;
   6259   if (0 == err)
   6260     daemon->sigpipe_blocked = true;
   6261 #ifdef HAVE_MESSAGES
   6262   else
   6263     MHD_DLOG (daemon,
   6264               _ ("Failed to block SIGPIPE on daemon thread: %s\n"),
   6265               MHD_strerror_ (errno));
   6266 #endif /* HAVE_MESSAGES */
   6267 #endif /* HAVE_PTHREAD_SIGMASK */
   6268   while (! daemon->shutdown)
   6269   {
   6270 #ifdef HAVE_POLL
   6271     if (MHD_D_IS_USING_POLL_ (daemon))
   6272       MHD_poll (daemon, MHD_YES);
   6273     else
   6274 #endif /* HAVE_POLL */
   6275 #ifdef EPOLL_SUPPORT
   6276     if (MHD_D_IS_USING_EPOLL_ (daemon))
   6277       MHD_epoll (daemon, -1);
   6278     else
   6279 #endif
   6280     MHD_select (daemon, -1);
   6281     MHD_cleanup_connections (daemon);
   6282   }
   6283 
   6284   /* Resume any pending for resume connections, join
   6285    * all connection's threads (if any) and finally cleanup
   6286    * everything. */
   6287   if (0 != (MHD_TEST_ALLOW_SUSPEND_RESUME & daemon->options))
   6288     resume_suspended_connections (daemon);
   6289   close_all_connections (daemon);
   6290 
   6291   return (MHD_THRD_RTRN_TYPE_) 0;
   6292 }
   6293 
   6294 
   6295 #endif
   6296 
   6297 
   6298 /**
   6299  * Process escape sequences ('%HH') Updates val in place; the
   6300  * result cannot be larger than the input.
   6301  * The result must also still be 0-terminated.
   6302  *
   6303  * @param cls closure (use NULL)
   6304  * @param connection handle to connection, not used
   6305  * @param val value to unescape (modified in the process)
   6306  * @return length of the resulting val (strlen(val) maybe
   6307  *  shorter afterwards due to elimination of escape sequences)
   6308  */
   6309 static size_t
   6310 unescape_wrapper (void *cls,
   6311                   struct MHD_Connection *connection,
   6312                   char *val)
   6313 {
   6314   bool broken;
   6315   size_t res;
   6316   (void) cls; /* Mute compiler warning. */
   6317 
   6318   /* TODO: add individual parameter */
   6319   if (0 <= connection->daemon->client_discipline)
   6320     return MHD_str_pct_decode_in_place_strict_ (val);
   6321 
   6322   res = MHD_str_pct_decode_in_place_lenient_ (val, &broken);
   6323 #ifdef HAVE_MESSAGES
   6324   if (broken)
   6325   {
   6326     MHD_DLOG (connection->daemon,
   6327               _ ("The URL encoding is broken.\n"));
   6328   }
   6329 #endif /* HAVE_MESSAGES */
   6330   return res;
   6331 }
   6332 
   6333 
   6334 /**
   6335  * Start a webserver on the given port.  Variadic version of
   6336  * #MHD_start_daemon_va.
   6337  *
   6338  * @param flags combination of `enum MHD_FLAG` values
   6339  * @param port port to bind to (in host byte order),
   6340  *        use '0' to bind to random free port,
   6341  *        ignored if #MHD_OPTION_SOCK_ADDR or
   6342  *        #MHD_OPTION_LISTEN_SOCKET is provided
   6343  *        or #MHD_USE_NO_LISTEN_SOCKET is specified
   6344  * @param apc callback to call to check which clients
   6345  *        will be allowed to connect; you can pass NULL
   6346  *        in which case connections from any IP will be
   6347  *        accepted
   6348  * @param apc_cls extra argument to @a apc
   6349  * @param dh handler called for all requests (repeatedly)
   6350  * @param dh_cls extra argument to @a dh
   6351  * @return NULL on error, handle to daemon on success
   6352  * @ingroup event
   6353  */
   6354 _MHD_EXTERN struct MHD_Daemon *
   6355 MHD_start_daemon (unsigned int flags,
   6356                   uint16_t port,
   6357                   MHD_AcceptPolicyCallback apc,
   6358                   void *apc_cls,
   6359                   MHD_AccessHandlerCallback dh,
   6360                   void *dh_cls,
   6361                   ...)
   6362 {
   6363   struct MHD_Daemon *daemon;
   6364   va_list ap;
   6365 
   6366   va_start (ap,
   6367             dh_cls);
   6368   daemon = MHD_start_daemon_va (flags,
   6369                                 port,
   6370                                 apc,
   6371                                 apc_cls,
   6372                                 dh,
   6373                                 dh_cls,
   6374                                 ap);
   6375   va_end (ap);
   6376   return daemon;
   6377 }
   6378 
   6379 
   6380 /**
   6381  * Stop accepting connections from the listening socket.  Allows
   6382  * clients to continue processing, but stops accepting new
   6383  * connections.  Note that the caller is responsible for closing the
   6384  * returned socket; however, if MHD is run using threads (anything but
   6385  * external select mode), socket will be removed from existing threads
   6386  * with some delay and it must not be closed while it's in use. To make
   6387  * sure that the socket is not used anymore, call #MHD_stop_daemon.
   6388  *
   6389  * Note that some thread modes require the caller to have passed
   6390  * #MHD_USE_ITC when using this API.  If this daemon is
   6391  * in one of those modes and this option was not given to
   6392  * #MHD_start_daemon, this function will return #MHD_INVALID_SOCKET.
   6393  *
   6394  * @param daemon daemon to stop accepting new connections for
   6395  * @return old listen socket on success, #MHD_INVALID_SOCKET if
   6396  *         the daemon was already not listening anymore
   6397  * @ingroup specialized
   6398  */
   6399 _MHD_EXTERN MHD_socket
   6400 MHD_quiesce_daemon (struct MHD_Daemon *daemon)
   6401 {
   6402 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6403   unsigned int i;
   6404 #endif
   6405   MHD_socket ret;
   6406 
   6407   ret = daemon->listen_fd;
   6408   if ((MHD_INVALID_SOCKET == ret)
   6409       || daemon->was_quiesced)
   6410     return MHD_INVALID_SOCKET;
   6411   if ( (0 == (daemon->options & (MHD_USE_ITC))) &&
   6412        MHD_D_IS_USING_THREADS_ (daemon) )
   6413   {
   6414 #ifdef HAVE_MESSAGES
   6415     MHD_DLOG (daemon,
   6416               _ ("Using MHD_quiesce_daemon in this mode " \
   6417                  "requires MHD_USE_ITC.\n"));
   6418 #endif
   6419     return MHD_INVALID_SOCKET;
   6420   }
   6421 
   6422 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6423   if (NULL != daemon->worker_pool)
   6424     for (i = 0; i < daemon->worker_pool_size; i++)
   6425     {
   6426       /* Each worker is an independent daemon with its own epoll set and
   6427          its own lock; they are taken one at a time and never nested, so
   6428          there is no ordering to get wrong.  Holding the worker's lock
   6429          is what stops it removing the same descriptor concurrently from
   6430          its own MHD_epoll(). */
   6431 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6432       MHD_mutex_lock_chk_ (&daemon->worker_pool[i].epoll_listen_mutex);
   6433 #endif
   6434       daemon->worker_pool[i].was_quiesced = true;
   6435 #ifdef EPOLL_SUPPORT
   6436       if (MHD_D_IS_USING_EPOLL_ (daemon) &&
   6437           (-1 != daemon->worker_pool[i].epoll_fd) &&
   6438           (daemon->worker_pool[i].listen_socket_in_epoll) )
   6439       {
   6440         if (0 != epoll_ctl (daemon->worker_pool[i].epoll_fd,
   6441                             EPOLL_CTL_DEL,
   6442                             ret,
   6443                             NULL))
   6444           MHD_PANIC (_ ("Failed to remove listen FD from epoll set.\n"));
   6445         daemon->worker_pool[i].listen_socket_in_epoll = false;
   6446       }
   6447       else
   6448 #endif
   6449       if (MHD_ITC_IS_VALID_ (daemon->worker_pool[i].itc))
   6450       {
   6451         if (! MHD_itc_activate_ (daemon->worker_pool[i].itc, "q"))
   6452           MHD_PANIC (_ ("Failed to signal quiesce via inter-thread " \
   6453                         "communication channel.\n"));
   6454       }
   6455 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6456       MHD_mutex_unlock_chk_ (&daemon->worker_pool[i].epoll_listen_mutex);
   6457 #endif
   6458     }
   6459 #endif
   6460 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6461   MHD_mutex_lock_chk_ (&daemon->epoll_listen_mutex);
   6462 #endif
   6463   daemon->was_quiesced = true;
   6464 #ifdef EPOLL_SUPPORT
   6465   if (MHD_D_IS_USING_EPOLL_ (daemon) &&
   6466       (-1 != daemon->epoll_fd) &&
   6467       (daemon->listen_socket_in_epoll) )
   6468   {
   6469     if (0 != epoll_ctl (daemon->epoll_fd,
   6470                         EPOLL_CTL_DEL,
   6471                         ret,
   6472                         NULL))
   6473       MHD_PANIC ("Failed to remove listen FD from epoll set.\n");
   6474     daemon->listen_socket_in_epoll = false;
   6475   }
   6476 #endif
   6477 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   6478   MHD_mutex_unlock_chk_ (&daemon->epoll_listen_mutex);
   6479 #endif
   6480   if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
   6481        (! MHD_itc_activate_ (daemon->itc, "q")) )
   6482     MHD_PANIC (_ ("failed to signal quiesce via inter-thread " \
   6483                   "communication channel.\n"));
   6484   return ret;
   6485 }
   6486 
   6487 
   6488 /**
   6489  * Temporal location of the application-provided parameters/options.
   6490  * Used when options are decoded from #MHD_start_deamon() parameters, but
   6491  * not yet processed/applied.
   6492  */
   6493 struct MHD_InterimParams_
   6494 {
   6495   /**
   6496    * The total number of all user options used.
   6497    *
   6498    * Contains number only of meaningful options, i.e. #MHD_OPTION_END and
   6499    * #MHD_OPTION_ARRAY themselves are not counted, while options inside
   6500    * #MHD_OPTION_ARRAY are counted.
   6501    */
   6502   size_t num_opts;
   6503   /**
   6504    * Set to 'true' if @a fdset_size is set by application.
   6505    */
   6506   bool fdset_size_set;
   6507   /**
   6508    * The value for #MHD_OPTION_APP_FD_SETSIZE set by application.
   6509    */
   6510   int fdset_size;
   6511   /**
   6512    * Set to 'true' if @a listen_fd is set by application.
   6513    */
   6514   bool listen_fd_set;
   6515   /**
   6516    * Application-provided listen socket.
   6517    */
   6518   MHD_socket listen_fd;
   6519   /**
   6520    * Set to 'true' if @a server_addr is set by application.
   6521    */
   6522   bool pserver_addr_set;
   6523   /**
   6524    * Application-provided struct sockaddr to bind server to.
   6525    */
   6526   const struct sockaddr *pserver_addr;
   6527   /**
   6528    * Set to 'true' if @a server_addr_len is set by application.
   6529    */
   6530   bool server_addr_len_set;
   6531   /**
   6532    * Applicaiton-provided the size of the memory pointed by @a server_addr.
   6533    */
   6534   socklen_t server_addr_len;
   6535 };
   6536 
   6537 /**
   6538  * Signature of the MHD custom logger function.
   6539  *
   6540  * @param cls closure
   6541  * @param format format string
   6542  * @param va arguments to the format string (fprintf-style)
   6543  */
   6544 typedef void
   6545 (*VfprintfFunctionPointerType)(void *cls,
   6546                                const char *format,
   6547                                va_list va);
   6548 
   6549 
   6550 /**
   6551  * Parse a list of options given as varargs.
   6552  *
   6553  * @param daemon the daemon to initialize
   6554  * @param servaddr where to store the server's listen address
   6555  * @param params the interim parameters to be assigned to
   6556  * @param ap the options
   6557  * @return #MHD_YES on success, #MHD_NO on error
   6558  */
   6559 static enum MHD_Result
   6560 parse_options_va (struct MHD_Daemon *daemon,
   6561                   struct MHD_InterimParams_ *params,
   6562                   va_list ap);
   6563 
   6564 
   6565 /**
   6566  * Parse a list of options given as varargs.
   6567  *
   6568  * @param daemon the daemon to initialize
   6569  * @param servaddr where to store the server's listen address
   6570  * @param params the interim parameters to be assigned to
   6571  * @param ... the options
   6572  * @return #MHD_YES on success, #MHD_NO on error
   6573  */
   6574 static enum MHD_Result
   6575 parse_options (struct MHD_Daemon *daemon,
   6576                struct MHD_InterimParams_ *params,
   6577                ...)
   6578 {
   6579   va_list ap;
   6580   enum MHD_Result ret;
   6581 
   6582   va_start (ap, params);
   6583   ret = parse_options_va (daemon,
   6584                           params,
   6585                           ap);
   6586   va_end (ap);
   6587   return ret;
   6588 }
   6589 
   6590 
   6591 #ifdef HTTPS_SUPPORT
   6592 /**
   6593  * Type of GnuTLS priorities base string
   6594  */
   6595 enum MHD_TlsPrioritiesBaseType
   6596 {
   6597   MHD_TLS_PRIO_BASE_LIBMHD = 0, /**< @c "@LIBMICROHTTPD" */
   6598   MHD_TLS_PRIO_BASE_SYSTEM = 1, /**< @c "@SYSTEM" */
   6599 #if GNUTLS_VERSION_NUMBER >= 0x030300
   6600   MHD_TLS_PRIO_BASE_DEFAULT,    /**< Default priorities string */
   6601 #endif /* GNUTLS_VERSION_NUMBER >= 0x030300 */
   6602   MHD_TLS_PRIO_BASE_NORMAL      /**< @c "NORMAL */
   6603 };
   6604 
   6605 static const struct _MHD_cstr_w_len MHD_TlsBasePriotities[] = {
   6606   _MHD_S_STR_W_LEN ("@LIBMICROHTTPD"),
   6607   _MHD_S_STR_W_LEN ("@SYSTEM"),
   6608 #if GNUTLS_VERSION_NUMBER >= 0x030300
   6609   {NULL, 0},
   6610 #endif /* GNUTLS_VERSION_NUMBER >= 0x030300 */
   6611   _MHD_S_STR_W_LEN ("NORMAL")
   6612 };
   6613 
   6614 /**
   6615  * Initialise TLS priorities with default settings
   6616  * @param daemon the daemon to initialise TLS priorities
   6617  * @return true on success, false on error
   6618  */
   6619 static bool
   6620 daemon_tls_priorities_init_default (struct MHD_Daemon *daemon)
   6621 {
   6622   unsigned int p;
   6623   int res;
   6624 
   6625   mhd_assert (0 != (((unsigned int) daemon->options) & MHD_USE_TLS));
   6626   mhd_assert (NULL == daemon->priority_cache);
   6627   mhd_assert (MHD_TLS_PRIO_BASE_NORMAL + 1 == \
   6628               sizeof(MHD_TlsBasePriotities) / sizeof(MHD_TlsBasePriotities[0]));
   6629 
   6630   res = GNUTLS_E_SUCCESS; /* Mute compiler warning */
   6631 
   6632   for (p = 0;
   6633        p < sizeof(MHD_TlsBasePriotities) / sizeof(MHD_TlsBasePriotities[0]);
   6634        ++p)
   6635   {
   6636     res = gnutls_priority_init (&daemon->priority_cache,
   6637                                 MHD_TlsBasePriotities[p].str, NULL);
   6638     if (GNUTLS_E_SUCCESS == res)
   6639     {
   6640 #ifdef _DEBUG
   6641 #ifdef HAVE_MESSAGES
   6642       switch ((enum MHD_TlsPrioritiesBaseType) p)
   6643       {
   6644       case MHD_TLS_PRIO_BASE_LIBMHD:
   6645         MHD_DLOG (daemon,
   6646                   _ ("GnuTLS priorities have been initialised with " \
   6647                      "@LIBMICROHTTPD application-specific system-wide " \
   6648                      "configuration.\n") );
   6649         break;
   6650       case MHD_TLS_PRIO_BASE_SYSTEM:
   6651         MHD_DLOG (daemon,
   6652                   _ ("GnuTLS priorities have been initialised with " \
   6653                      "@SYSTEM system-wide configuration.\n") );
   6654         break;
   6655 #if GNUTLS_VERSION_NUMBER >= 0x030300
   6656       case MHD_TLS_PRIO_BASE_DEFAULT:
   6657         MHD_DLOG (daemon,
   6658                   _ ("GnuTLS priorities have been initialised with " \
   6659                      "GnuTLS default configuration.\n") );
   6660         break;
   6661 #endif /* GNUTLS_VERSION_NUMBER >= 0x030300 */
   6662       case MHD_TLS_PRIO_BASE_NORMAL:
   6663         MHD_DLOG (daemon,
   6664                   _ ("GnuTLS priorities have been initialised with " \
   6665                      "NORMAL configuration.\n") );
   6666         break;
   6667       default:
   6668         mhd_assert (0);
   6669       }
   6670 #endif /* HAVE_MESSAGES */
   6671 #endif /* _DEBUG */
   6672       return true;
   6673     }
   6674   }
   6675 #ifdef HAVE_MESSAGES
   6676   MHD_DLOG (daemon,
   6677             _ ("Failed to set GnuTLS priorities. Last error: %s\n"),
   6678             gnutls_strerror (res));
   6679 #endif /* HAVE_MESSAGES */
   6680   return false;
   6681 }
   6682 
   6683 
   6684 /**
   6685  * The inner helper function for #daemon_tls_priorities_init_app().
   6686  * @param daemon the daemon to use
   6687  * @param prio   the appication-specified appendix for default priorities
   6688  * @param prio_len the length of @a prio
   6689  * @param buf    the temporal buffer for string manipulations
   6690  * @param buf_size the size of the @a buf
   6691  * @return true on success, false on error
   6692  */
   6693 static bool
   6694 daemon_tls_priorities_init_append_inner_ (struct MHD_Daemon *daemon,
   6695                                           const char *prio,
   6696                                           size_t prio_len,
   6697                                           char *buf,
   6698                                           const size_t buf_size)
   6699 {
   6700   unsigned int p;
   6701   int res;
   6702   const char *err_pos;
   6703 
   6704   (void) buf_size; /* Mute compiler warning for non-Debug builds */
   6705   mhd_assert (0 != (((unsigned int) daemon->options) & MHD_USE_TLS));
   6706   mhd_assert (NULL == daemon->priority_cache);
   6707   mhd_assert (MHD_TLS_PRIO_BASE_NORMAL + 1 == \
   6708               sizeof(MHD_TlsBasePriotities) / sizeof(MHD_TlsBasePriotities[0]));
   6709 
   6710   res = GNUTLS_E_SUCCESS; /* Mute compiler warning */
   6711 
   6712   for (p = 0;
   6713        p < sizeof(MHD_TlsBasePriotities) / sizeof(MHD_TlsBasePriotities[0]);
   6714        ++p)
   6715   {
   6716 
   6717 #if GNUTLS_VERSION_NUMBER >= 0x030300
   6718 #if GNUTLS_VERSION_NUMBER >= 0x030603
   6719     if (NULL == MHD_TlsBasePriotities[p].str)
   6720       res = gnutls_priority_init2 (&daemon->priority_cache, prio, &err_pos,
   6721                                    GNUTLS_PRIORITY_INIT_DEF_APPEND);
   6722     else
   6723 #else /* 0x030300 <= GNUTLS_VERSION_NUMBER
   6724          && GNUTLS_VERSION_NUMBER < 0x030603 */
   6725     if (NULL == MHD_TlsBasePriotities[p].str)
   6726       continue; /* Skip the value, no way to append priorities to the default string */
   6727     else
   6728 #endif /* GNUTLS_VERSION_NUMBER < 0x030603 */
   6729 #endif /* GNUTLS_VERSION_NUMBER >= 0x030300 */
   6730     if (1)
   6731     {
   6732       size_t buf_pos;
   6733 
   6734       mhd_assert (NULL != MHD_TlsBasePriotities[p].str);
   6735       buf_pos = 0;
   6736       memcpy (buf + buf_pos, MHD_TlsBasePriotities[p].str,
   6737               MHD_TlsBasePriotities[p].len);
   6738       buf_pos += MHD_TlsBasePriotities[p].len;
   6739       buf[buf_pos++] = ':';
   6740       memcpy (buf + buf_pos, prio, prio_len + 1);
   6741 #ifdef _DEBUG
   6742       buf_pos += prio_len + 1;
   6743       mhd_assert (buf_size >= buf_pos);
   6744 #endif /* _DEBUG */
   6745       res = gnutls_priority_init (&daemon->priority_cache, buf, &err_pos);
   6746     }
   6747     if (GNUTLS_E_SUCCESS == res)
   6748     {
   6749 #ifdef _DEBUG
   6750 #ifdef HAVE_MESSAGES
   6751       switch ((enum MHD_TlsPrioritiesBaseType) p)
   6752       {
   6753       case MHD_TLS_PRIO_BASE_LIBMHD:
   6754         MHD_DLOG (daemon,
   6755                   _ ("GnuTLS priorities have been initialised with " \
   6756                      "priorities specified by application appended to " \
   6757                      "@LIBMICROHTTPD application-specific system-wide " \
   6758                      "configuration.\n") );
   6759         break;
   6760       case MHD_TLS_PRIO_BASE_SYSTEM:
   6761         MHD_DLOG (daemon,
   6762                   _ ("GnuTLS priorities have been initialised with " \
   6763                      "priorities specified by application appended to " \
   6764                      "@SYSTEM system-wide configuration.\n") );
   6765         break;
   6766 #if GNUTLS_VERSION_NUMBER >= 0x030300
   6767       case MHD_TLS_PRIO_BASE_DEFAULT:
   6768         MHD_DLOG (daemon,
   6769                   _ ("GnuTLS priorities have been initialised with " \
   6770                      "priorities specified by application appended to " \
   6771                      "GnuTLS default configuration.\n") );
   6772         break;
   6773 #endif /* GNUTLS_VERSION_NUMBER >= 0x030300 */
   6774       case MHD_TLS_PRIO_BASE_NORMAL:
   6775         MHD_DLOG (daemon,
   6776                   _ ("GnuTLS priorities have been initialised with " \
   6777                      "priorities specified by application appended to " \
   6778                      "NORMAL configuration.\n") );
   6779         break;
   6780       default:
   6781         mhd_assert (0);
   6782       }
   6783 #endif /* HAVE_MESSAGES */
   6784 #endif /* _DEBUG */
   6785       return true;
   6786     }
   6787   }
   6788 #ifdef HAVE_MESSAGES
   6789   MHD_DLOG (daemon,
   6790             _ ("Failed to set GnuTLS priorities. Last error: %s. " \
   6791                "The problematic part starts at: %s\n"),
   6792             gnutls_strerror (res), err_pos);
   6793 #endif /* HAVE_MESSAGES */
   6794   return false;
   6795 }
   6796 
   6797 
   6798 #define LOCAL_BUFF_SIZE 128
   6799 
   6800 /**
   6801  * Initialise TLS priorities with default settings with application-specified
   6802  * appended string.
   6803  * @param daemon the daemon to initialise TLS priorities
   6804  * @param prio the application specified priorities to be appended to
   6805  *             the GnuTLS standard priorities string
   6806  * @return true on success, false on error
   6807  */
   6808 static bool
   6809 daemon_tls_priorities_init_append (struct MHD_Daemon *daemon, const char *prio)
   6810 {
   6811   static const size_t longest_base_prio = MHD_STATICSTR_LEN_ ("@LIBMICROHTTPD");
   6812   bool ret;
   6813   size_t prio_len;
   6814   size_t buf_size_needed;
   6815 
   6816   if (NULL == prio)
   6817     return daemon_tls_priorities_init_default (daemon);
   6818 
   6819   if (':' == prio[0])
   6820     ++prio;
   6821 
   6822   prio_len = strlen (prio);
   6823 
   6824   buf_size_needed = longest_base_prio + 1 + prio_len + 1;
   6825 
   6826   if (LOCAL_BUFF_SIZE >= buf_size_needed)
   6827   {
   6828     char local_buffer[LOCAL_BUFF_SIZE];
   6829     ret = daemon_tls_priorities_init_append_inner_ (daemon, prio, prio_len,
   6830                                                     local_buffer,
   6831                                                     LOCAL_BUFF_SIZE);
   6832   }
   6833   else
   6834   {
   6835     char *allocated_buffer;
   6836     allocated_buffer = (char *) malloc (buf_size_needed);
   6837     if (NULL == allocated_buffer)
   6838     {
   6839 #ifdef HAVE_MESSAGES
   6840       MHD_DLOG (daemon,
   6841                 _ ("Error allocating memory: %s\n"),
   6842                 MHD_strerror_ (errno));
   6843 #endif
   6844       return false;
   6845     }
   6846     ret = daemon_tls_priorities_init_append_inner_ (daemon, prio, prio_len,
   6847                                                     allocated_buffer,
   6848                                                     buf_size_needed);
   6849     free (allocated_buffer);
   6850   }
   6851   return ret;
   6852 }
   6853 
   6854 
   6855 #endif /* HTTPS_SUPPORT */
   6856 
   6857 
   6858 /**
   6859  * Parse a list of options given as varargs.
   6860  *
   6861  * @param[in,out] daemon the daemon to initialize
   6862  * @param[out] params the interim parameters to be assigned to
   6863  * @param ap the options
   6864  * @return #MHD_YES on success, #MHD_NO on error
   6865  */
   6866 static enum MHD_Result
   6867 parse_options_va (struct MHD_Daemon *daemon,
   6868                   struct MHD_InterimParams_ *params,
   6869                   va_list ap)
   6870 {
   6871   enum MHD_OPTION opt;
   6872   struct MHD_OptionItem *oa;
   6873   unsigned int i;
   6874   unsigned int uv;
   6875 #ifdef HTTPS_SUPPORT
   6876   const char *pstr;
   6877 #if GNUTLS_VERSION_MAJOR >= 3
   6878   gnutls_certificate_retrieve_function2 * pgcrf;
   6879 #endif
   6880 #if GNUTLS_VERSION_NUMBER >= 0x030603
   6881   gnutls_certificate_retrieve_function3 * pgcrf2;
   6882 #endif
   6883 #endif /* HTTPS_SUPPORT */
   6884 
   6885   while (MHD_OPTION_END != (opt = (enum MHD_OPTION) va_arg (ap, int)))
   6886   {
   6887     /* Increase counter at start, so resulting value is number of
   6888      * processed options, including any failed ones. */
   6889     params->num_opts++;
   6890     switch (opt)
   6891     {
   6892     case MHD_OPTION_CONNECTION_MEMORY_LIMIT:
   6893       if (1)
   6894       {
   6895         size_t val;
   6896 
   6897         val = va_arg (ap,
   6898                       size_t);
   6899         if (0 != val)
   6900         {
   6901           daemon->pool_size = val;
   6902           if (64 > daemon->pool_size)
   6903           {
   6904 #ifdef HAVE_MESSAGES
   6905             MHD_DLOG (daemon,
   6906                       _ ("Warning: specified " \
   6907                          "MHD_OPTION_CONNECTION_MEMORY_LIMIT " \
   6908                          "value is too small and rounded up to 64.\n"));
   6909 #endif /* HAVE_MESSAGES */
   6910             daemon->pool_size = 64;
   6911           }
   6912           if (daemon->pool_size / 4 < daemon->pool_increment)
   6913             daemon->pool_increment = daemon->pool_size / 4;
   6914         }
   6915       }
   6916       break;
   6917     case MHD_OPTION_CONNECTION_MEMORY_INCREMENT:
   6918       if (1)
   6919       {
   6920         size_t val;
   6921 
   6922         val = va_arg (ap,
   6923                       size_t);
   6924 
   6925         if (0 != val)
   6926         {
   6927           daemon->pool_increment = val;
   6928           if (daemon->pool_size / 4 < daemon->pool_increment)
   6929           {
   6930 #ifdef HAVE_MESSAGES
   6931             MHD_DLOG (daemon,
   6932                       _ ("Warning: specified " \
   6933                          "MHD_OPTION_CONNECTION_MEMORY_INCREMENT value is " \
   6934                          "too large and rounded down to 1/4 of " \
   6935                          "MHD_OPTION_CONNECTION_MEMORY_LIMIT.\n"));
   6936 #endif /* HAVE_MESSAGES */
   6937             daemon->pool_increment = daemon->pool_size / 4;
   6938           }
   6939         }
   6940       }
   6941       break;
   6942     case MHD_OPTION_CONNECTION_LIMIT:
   6943       daemon->connection_limit = va_arg (ap,
   6944                                          unsigned int);
   6945       break;
   6946     case MHD_OPTION_CONNECTION_TIMEOUT:
   6947       uv = va_arg (ap,
   6948                    unsigned int);
   6949 #if (SIZEOF_UINT64_T - 2) <= SIZEOF_UNSIGNED_INT
   6950       if ((UINT64_MAX / 4000 - 1) < uv)
   6951       {
   6952 #ifdef HAVE_MESSAGES
   6953         MHD_DLOG (daemon,
   6954                   _ ("The specified connection timeout (%u) is too large. " \
   6955                      "Maximum allowed value (%" PRIu64 ") will be used " \
   6956                      "instead.\n"),
   6957                   uv,
   6958                   (UINT64_MAX / 4000 - 1));
   6959 #endif
   6960         uv = UINT64_MAX / 4000 - 1;
   6961       }
   6962 #endif /* (SIZEOF_UINT64_T - 2) <= SIZEOF_UNSIGNED_INT */
   6963       daemon->connection_timeout_ms = ((uint64_t) uv) * 1000;
   6964       break;
   6965     case MHD_OPTION_NOTIFY_COMPLETED:
   6966       daemon->notify_completed = va_arg (ap,
   6967                                          MHD_RequestCompletedCallback);
   6968       daemon->notify_completed_cls = va_arg (ap,
   6969                                              void *);
   6970       break;
   6971     case MHD_OPTION_NOTIFY_CONNECTION:
   6972       daemon->notify_connection = va_arg (ap,
   6973                                           MHD_NotifyConnectionCallback);
   6974       daemon->notify_connection_cls = va_arg (ap,
   6975                                               void *);
   6976       break;
   6977     case MHD_OPTION_PER_IP_CONNECTION_LIMIT:
   6978       daemon->per_ip_connection_limit = va_arg (ap,
   6979                                                 unsigned int);
   6980       break;
   6981     case MHD_OPTION_SOCK_ADDR_LEN:
   6982       params->server_addr_len = va_arg (ap,
   6983                                         socklen_t);
   6984       params->server_addr_len_set = true;
   6985       params->pserver_addr = va_arg (ap,
   6986                                      const struct sockaddr *);
   6987       params->pserver_addr_set = true;
   6988       break;
   6989     case MHD_OPTION_SOCK_ADDR:
   6990       params->server_addr_len_set = false;
   6991       params->pserver_addr = va_arg (ap,
   6992                                      const struct sockaddr *);
   6993       params->pserver_addr_set = true;
   6994       break;
   6995     case MHD_OPTION_URI_LOG_CALLBACK:
   6996       daemon->uri_log_callback = va_arg (ap,
   6997                                          LogCallback);
   6998       daemon->uri_log_callback_cls = va_arg (ap,
   6999                                              void *);
   7000       break;
   7001     case MHD_OPTION_SERVER_INSANITY:
   7002       daemon->insanity_level = (enum MHD_DisableSanityCheck)
   7003                                va_arg (ap,
   7004                                        unsigned int);
   7005       break;
   7006 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   7007     case MHD_OPTION_THREAD_POOL_SIZE:
   7008       daemon->worker_pool_size = va_arg (ap,
   7009                                          unsigned int);
   7010       if (0 == daemon->worker_pool_size)
   7011       {
   7012         (void) 0; /* MHD_OPTION_THREAD_POOL_SIZE ignored, do nothing */
   7013       }
   7014       else if (1 == daemon->worker_pool_size)
   7015       {
   7016 #ifdef HAVE_MESSAGES
   7017         MHD_DLOG (daemon,
   7018                   _ ("Warning: value \"1\", specified as the thread pool " \
   7019                      "size, is ignored. Thread pool is not used.\n"));
   7020 #endif
   7021         daemon->worker_pool_size = 0;
   7022       }
   7023 #if SIZEOF_UNSIGNED_INT >= (SIZEOF_SIZE_T - 2)
   7024       /* Next comparison could be always false on some platforms and whole branch will
   7025        * be optimized out on these platforms. On others it will be compiled into real
   7026        * check. */
   7027       else if (daemon->worker_pool_size >=
   7028                (SIZE_MAX / sizeof (struct MHD_Daemon)))            /* Compiler may warn on some platforms, ignore warning. */
   7029       {
   7030 #ifdef HAVE_MESSAGES
   7031         MHD_DLOG (daemon,
   7032                   _ ("Specified thread pool size (%u) too big.\n"),
   7033                   daemon->worker_pool_size);
   7034 #endif
   7035         return MHD_NO;
   7036       }
   7037 #endif /* SIZEOF_UNSIGNED_INT >= (SIZEOF_SIZE_T - 2) */
   7038       else
   7039       {
   7040         if (! MHD_D_IS_USING_THREADS_ (daemon))
   7041         {
   7042 #ifdef HAVE_MESSAGES
   7043           MHD_DLOG (daemon,
   7044                     _ ("MHD_OPTION_THREAD_POOL_SIZE option is specified but "
   7045                        "MHD_USE_INTERNAL_POLLING_THREAD flag is not specified.\n"));
   7046 #endif
   7047           return MHD_NO;
   7048         }
   7049         if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   7050         {
   7051 #ifdef HAVE_MESSAGES
   7052           MHD_DLOG (daemon,
   7053                     _ ("Both MHD_OPTION_THREAD_POOL_SIZE option and "
   7054                        "MHD_USE_THREAD_PER_CONNECTION flag are specified.\n"));
   7055 #endif
   7056           return MHD_NO;
   7057         }
   7058       }
   7059       break;
   7060 #endif
   7061 #ifdef HTTPS_SUPPORT
   7062     case MHD_OPTION_HTTPS_MEM_KEY:
   7063       pstr = va_arg (ap,
   7064                      const char *);
   7065       if (0 != (daemon->options & MHD_USE_TLS))
   7066         daemon->https_mem_key = pstr;
   7067 #ifdef HAVE_MESSAGES
   7068       else
   7069         MHD_DLOG (daemon,
   7070                   _ ("MHD HTTPS option %d passed to MHD but " \
   7071                      "MHD_USE_TLS not set.\n"),
   7072                   opt);
   7073 #endif
   7074       break;
   7075     case MHD_OPTION_HTTPS_KEY_PASSWORD:
   7076       pstr = va_arg (ap,
   7077                      const char *);
   7078       if (0 != (daemon->options & MHD_USE_TLS))
   7079         daemon->https_key_password = pstr;
   7080 #ifdef HAVE_MESSAGES
   7081       else
   7082         MHD_DLOG (daemon,
   7083                   _ ("MHD HTTPS option %d passed to MHD but " \
   7084                      "MHD_USE_TLS not set.\n"),
   7085                   opt);
   7086 #endif
   7087       break;
   7088     case MHD_OPTION_HTTPS_MEM_CERT:
   7089       pstr = va_arg (ap,
   7090                      const char *);
   7091       if (0 != (daemon->options & MHD_USE_TLS))
   7092         daemon->https_mem_cert = pstr;
   7093 #ifdef HAVE_MESSAGES
   7094       else
   7095         MHD_DLOG (daemon,
   7096                   _ ("MHD HTTPS option %d passed to MHD but " \
   7097                      "MHD_USE_TLS not set.\n"),
   7098                   opt);
   7099 #endif
   7100       break;
   7101     case MHD_OPTION_HTTPS_MEM_TRUST:
   7102       pstr = va_arg (ap,
   7103                      const char *);
   7104       if (0 != (daemon->options & MHD_USE_TLS))
   7105         daemon->https_mem_trust = pstr;
   7106 #ifdef HAVE_MESSAGES
   7107       else
   7108         MHD_DLOG (daemon,
   7109                   _ ("MHD HTTPS option %d passed to MHD but " \
   7110                      "MHD_USE_TLS not set.\n"),
   7111                   opt);
   7112 #endif
   7113       break;
   7114     case MHD_OPTION_HTTPS_CRED_TYPE:
   7115       daemon->cred_type = (gnutls_credentials_type_t) va_arg (ap,
   7116                                                               int);
   7117       break;
   7118     case MHD_OPTION_HTTPS_MEM_DHPARAMS:
   7119       pstr = va_arg (ap,
   7120                      const char *);
   7121       if (0 != (daemon->options & MHD_USE_TLS))
   7122       {
   7123         gnutls_datum_t dhpar;
   7124         size_t pstr_len;
   7125 
   7126         if (gnutls_dh_params_init (&daemon->https_mem_dhparams) < 0)
   7127         {
   7128 #ifdef HAVE_MESSAGES
   7129           MHD_DLOG (daemon,
   7130                     _ ("Error initializing DH parameters.\n"));
   7131 #endif
   7132           return MHD_NO;
   7133         }
   7134         dhpar.data = (unsigned char *) _MHD_DROP_CONST (pstr);
   7135         pstr_len = strlen (pstr);
   7136         if (UINT_MAX < pstr_len)
   7137         {
   7138 #ifdef HAVE_MESSAGES
   7139           MHD_DLOG (daemon,
   7140                     _ ("Diffie-Hellman parameters string too long.\n"));
   7141 #endif
   7142           return MHD_NO;
   7143         }
   7144         dhpar.size = (unsigned int) pstr_len;
   7145         if (gnutls_dh_params_import_pkcs3 (daemon->https_mem_dhparams,
   7146                                            &dhpar,
   7147                                            GNUTLS_X509_FMT_PEM) < 0)
   7148         {
   7149 #ifdef HAVE_MESSAGES
   7150           MHD_DLOG (daemon,
   7151                     _ ("Bad Diffie-Hellman parameters format.\n"));
   7152 #endif
   7153           gnutls_dh_params_deinit (daemon->https_mem_dhparams);
   7154           return MHD_NO;
   7155         }
   7156         daemon->have_dhparams = true;
   7157       }
   7158 #ifdef HAVE_MESSAGES
   7159       else
   7160         MHD_DLOG (daemon,
   7161                   _ ("MHD HTTPS option %d passed to MHD but " \
   7162                      "MHD_USE_TLS not set.\n"),
   7163                   opt);
   7164 #endif
   7165       break;
   7166     case MHD_OPTION_HTTPS_PRIORITIES:
   7167     case MHD_OPTION_HTTPS_PRIORITIES_APPEND:
   7168       pstr = va_arg (ap,
   7169                      const char *);
   7170       if (0 != (daemon->options & MHD_USE_TLS))
   7171       {
   7172         if (NULL != daemon->priority_cache)
   7173           gnutls_priority_deinit (daemon->priority_cache);
   7174 
   7175         if (MHD_OPTION_HTTPS_PRIORITIES == opt)
   7176         {
   7177           int init_res;
   7178           const char *err_pos;
   7179           init_res = gnutls_priority_init (&daemon->priority_cache,
   7180                                            pstr,
   7181                                            &err_pos);
   7182           if (GNUTLS_E_SUCCESS != init_res)
   7183           {
   7184 #ifdef HAVE_MESSAGES
   7185             MHD_DLOG (daemon,
   7186                       _ ("Setting priorities to '%s' failed: %s " \
   7187                          "The problematic part starts at: %s\n"),
   7188                       pstr,
   7189                       gnutls_strerror (init_res),
   7190                       err_pos);
   7191 #endif
   7192             daemon->priority_cache = NULL;
   7193             return MHD_NO;
   7194           }
   7195         }
   7196         else
   7197         {
   7198           /* The cache has been deinited */
   7199           daemon->priority_cache = NULL;
   7200           if (! daemon_tls_priorities_init_append (daemon, pstr))
   7201             return MHD_NO;
   7202         }
   7203       }
   7204 #ifdef HAVE_MESSAGES
   7205       else
   7206         MHD_DLOG (daemon,
   7207                   _ ("MHD HTTPS option %d passed to MHD but " \
   7208                      "MHD_USE_TLS not set.\n"),
   7209                   opt);
   7210 #endif
   7211       break;
   7212     case MHD_OPTION_HTTPS_CERT_CALLBACK:
   7213 #if GNUTLS_VERSION_MAJOR < 3
   7214 #ifdef HAVE_MESSAGES
   7215       MHD_DLOG (daemon,
   7216                 _ ("MHD_OPTION_HTTPS_CERT_CALLBACK requires building " \
   7217                    "MHD with GnuTLS >= 3.0.\n"));
   7218 #endif
   7219       return MHD_NO;
   7220 #else
   7221       pgcrf = va_arg (ap,
   7222                       gnutls_certificate_retrieve_function2 *);
   7223       if (0 != (daemon->options & MHD_USE_TLS))
   7224         daemon->cert_callback = pgcrf;
   7225 #ifdef HAVE_MESSAGES
   7226       else
   7227         MHD_DLOG (daemon,
   7228                   _ ("MHD HTTPS option %d passed to MHD but " \
   7229                      "MHD_USE_TLS not set.\n"),
   7230                   opt);
   7231 #endif /*  HAVE_MESSAGES */
   7232       break;
   7233 #endif
   7234     case MHD_OPTION_HTTPS_CERT_CALLBACK2:
   7235 #if GNUTLS_VERSION_NUMBER < 0x030603
   7236 #ifdef HAVE_MESSAGES
   7237       MHD_DLOG (daemon,
   7238                 _ ("MHD_OPTION_HTTPS_CERT_CALLBACK2 requires building " \
   7239                    "MHD with GnuTLS >= 3.6.3.\n"));
   7240 #endif
   7241       return MHD_NO;
   7242 #else
   7243       pgcrf2 = va_arg (ap,
   7244                        gnutls_certificate_retrieve_function3 *);
   7245       if (0 != (daemon->options & MHD_USE_TLS))
   7246         daemon->cert_callback2 = pgcrf2;
   7247 #ifdef HAVE_MESSAGES
   7248       else
   7249         MHD_DLOG (daemon,
   7250                   _ ("MHD HTTPS option %d passed to MHD but " \
   7251                      "MHD_USE_TLS not set.\n"),
   7252                   opt);
   7253 #endif /* HAVE_MESSAGES */
   7254       break;
   7255 #endif
   7256 #endif /* HTTPS_SUPPORT */
   7257 #ifdef DAUTH_SUPPORT
   7258     case MHD_OPTION_DIGEST_AUTH_RANDOM:
   7259     case MHD_OPTION_DIGEST_AUTH_RANDOM_COPY:
   7260       daemon->digest_auth_rand_size = va_arg (ap,
   7261                                               size_t);
   7262       daemon->digest_auth_random = va_arg (ap,
   7263                                            const char *);
   7264       if (MHD_OPTION_DIGEST_AUTH_RANDOM_COPY == opt)
   7265         /* Set to some non-NULL value just to indicate that copy is required. */
   7266         daemon->digest_auth_random_copy = daemon;
   7267       else
   7268         daemon->digest_auth_random_copy = NULL;
   7269       break;
   7270     case MHD_OPTION_NONCE_NC_SIZE:
   7271       daemon->nonce_nc_size = va_arg (ap,
   7272                                       unsigned int);
   7273       break;
   7274     case MHD_OPTION_DIGEST_AUTH_NONCE_BIND_TYPE:
   7275       daemon->dauth_bind_type = va_arg (ap,
   7276                                         unsigned int);
   7277       if (0 != (daemon->dauth_bind_type & MHD_DAUTH_BIND_NONCE_URI_PARAMS))
   7278         daemon->dauth_bind_type |= MHD_DAUTH_BIND_NONCE_URI;
   7279       break;
   7280     case MHD_OPTION_DIGEST_AUTH_DEFAULT_NONCE_TIMEOUT:
   7281       if (1)
   7282       {
   7283         unsigned int val;
   7284         val = va_arg (ap,
   7285                       unsigned int);
   7286         if (0 != val)
   7287           daemon->dauth_def_nonce_timeout = val;
   7288       }
   7289       break;
   7290     case MHD_OPTION_DIGEST_AUTH_DEFAULT_MAX_NC:
   7291       if (1)
   7292       {
   7293         uint32_t val;
   7294         val = va_arg (ap,
   7295                       uint32_t);
   7296         if (0 != val)
   7297           daemon->dauth_def_max_nc = val;
   7298       }
   7299       break;
   7300 #else  /* ! DAUTH_SUPPORT */
   7301     case MHD_OPTION_DIGEST_AUTH_RANDOM:
   7302     case MHD_OPTION_DIGEST_AUTH_RANDOM_COPY:
   7303     case MHD_OPTION_NONCE_NC_SIZE:
   7304     case MHD_OPTION_DIGEST_AUTH_NONCE_BIND_TYPE:
   7305     case MHD_OPTION_DIGEST_AUTH_DEFAULT_NONCE_TIMEOUT:
   7306     case MHD_OPTION_DIGEST_AUTH_DEFAULT_MAX_NC:
   7307 #ifdef HAVE_MESSAGES
   7308       MHD_DLOG (daemon,
   7309                 _ ("Digest Auth is disabled for this build " \
   7310                    "of GNU libmicrohttpd.\n"));
   7311 #endif /* HAVE_MESSAGES */
   7312       return MHD_NO;
   7313 #endif /* ! DAUTH_SUPPORT */
   7314     case MHD_OPTION_LISTEN_SOCKET:
   7315       params->listen_fd = va_arg (ap,
   7316                                   MHD_socket);
   7317       params->listen_fd_set = true;
   7318       break;
   7319     case MHD_OPTION_EXTERNAL_LOGGER:
   7320 #ifdef HAVE_MESSAGES
   7321       daemon->custom_error_log = va_arg (ap,
   7322                                          VfprintfFunctionPointerType);
   7323       daemon->custom_error_log_cls = va_arg (ap,
   7324                                              void *);
   7325       if (1 != params->num_opts)
   7326         MHD_DLOG (daemon,
   7327                   _ ("MHD_OPTION_EXTERNAL_LOGGER is not the first option "
   7328                      "specified for the daemon. Some messages may be "
   7329                      "printed by the standard MHD logger.\n"));
   7330 
   7331 #else
   7332       (void) va_arg (ap,
   7333                      VfprintfFunctionPointerType);
   7334       (void) va_arg (ap,
   7335                      void *);
   7336 #endif
   7337       break;
   7338 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   7339     case MHD_OPTION_THREAD_STACK_SIZE:
   7340       daemon->thread_stack_size = va_arg (ap,
   7341                                           size_t);
   7342       break;
   7343 #endif
   7344     case MHD_OPTION_TCP_FASTOPEN_QUEUE_SIZE:
   7345 #ifdef TCP_FASTOPEN
   7346       daemon->fastopen_queue_size = va_arg (ap,
   7347                                             unsigned int);
   7348       break;
   7349 #else  /* ! TCP_FASTOPEN */
   7350 #ifdef HAVE_MESSAGES
   7351       MHD_DLOG (daemon,
   7352                 _ ("TCP fastopen is not supported on this platform.\n"));
   7353 #endif /* HAVE_MESSAGES */
   7354       return MHD_NO;
   7355 #endif /* ! TCP_FASTOPEN */
   7356     case MHD_OPTION_LISTENING_ADDRESS_REUSE:
   7357       daemon->listening_address_reuse = va_arg (ap,
   7358                                                 unsigned int) ? 1 : -1;
   7359       break;
   7360     case MHD_OPTION_LISTEN_BACKLOG_SIZE:
   7361       daemon->listen_backlog_size = va_arg (ap,
   7362                                             unsigned int);
   7363       break;
   7364     case MHD_OPTION_STRICT_FOR_CLIENT:
   7365       daemon->client_discipline = va_arg (ap, int); /* Temporal assignment */
   7366       /* Map to correct value */
   7367       if (-1 >= daemon->client_discipline)
   7368         daemon->client_discipline = -3;
   7369       else if (1 <= daemon->client_discipline)
   7370         daemon->client_discipline = 1;
   7371 #ifdef HAVE_MESSAGES
   7372       if ( (0 != (daemon->options & MHD_USE_PEDANTIC_CHECKS)) &&
   7373            (1 != daemon->client_discipline) )
   7374       {
   7375         MHD_DLOG (daemon,
   7376                   _ ("Flag MHD_USE_PEDANTIC_CHECKS is ignored because "
   7377                      "another behaviour is specified by "
   7378                      "MHD_OPTION_STRICT_CLIENT.\n"));
   7379       }
   7380 #endif /* HAVE_MESSAGES */
   7381       break;
   7382     case MHD_OPTION_CLIENT_DISCIPLINE_LVL:
   7383       daemon->client_discipline = va_arg (ap, int);
   7384 #ifdef HAVE_MESSAGES
   7385       if ( (0 != (daemon->options & MHD_USE_PEDANTIC_CHECKS)) &&
   7386            (1 != daemon->client_discipline) )
   7387       {
   7388         MHD_DLOG (daemon,
   7389                   _ ("Flag MHD_USE_PEDANTIC_CHECKS is ignored because "
   7390                      "another behaviour is specified by "
   7391                      "MHD_OPTION_CLIENT_DISCIPLINE_LVL.\n"));
   7392       }
   7393 #endif /* HAVE_MESSAGES */
   7394       break;
   7395     case MHD_OPTION_ALLOW_BIN_ZERO_IN_URI_PATH:
   7396       daemon->allow_bzero_in_url = va_arg (ap, int);
   7397       if ((0 > daemon->allow_bzero_in_url) ||
   7398           (2 < daemon->allow_bzero_in_url))
   7399         daemon->allow_bzero_in_url = 1;
   7400       break;
   7401     case MHD_OPTION_ARRAY:
   7402       params->num_opts--; /* Do not count MHD_OPTION_ARRAY */
   7403       oa = va_arg (ap, struct MHD_OptionItem *);
   7404       i = 0;
   7405       while (MHD_OPTION_END != (opt = oa[i].option))
   7406       {
   7407         switch (opt)
   7408         {
   7409         /* all options taking 'size_t' */
   7410         case MHD_OPTION_CONNECTION_MEMORY_LIMIT:
   7411         case MHD_OPTION_CONNECTION_MEMORY_INCREMENT:
   7412         case MHD_OPTION_THREAD_STACK_SIZE:
   7413           if (MHD_NO == parse_options (daemon,
   7414                                        params,
   7415                                        opt,
   7416                                        (size_t) oa[i].value,
   7417                                        MHD_OPTION_END))
   7418             return MHD_NO;
   7419           break;
   7420         /* all options taking 'unsigned int' */
   7421         case MHD_OPTION_NONCE_NC_SIZE:
   7422         case MHD_OPTION_CONNECTION_LIMIT:
   7423         case MHD_OPTION_CONNECTION_TIMEOUT:
   7424         case MHD_OPTION_PER_IP_CONNECTION_LIMIT:
   7425         case MHD_OPTION_THREAD_POOL_SIZE:
   7426         case MHD_OPTION_TCP_FASTOPEN_QUEUE_SIZE:
   7427         case MHD_OPTION_LISTENING_ADDRESS_REUSE:
   7428         case MHD_OPTION_LISTEN_BACKLOG_SIZE:
   7429         case MHD_OPTION_SERVER_INSANITY:
   7430         case MHD_OPTION_DIGEST_AUTH_NONCE_BIND_TYPE:
   7431         case MHD_OPTION_DIGEST_AUTH_DEFAULT_NONCE_TIMEOUT:
   7432           if (MHD_NO == parse_options (daemon,
   7433                                        params,
   7434                                        opt,
   7435                                        (unsigned int) oa[i].value,
   7436                                        MHD_OPTION_END))
   7437             return MHD_NO;
   7438           break;
   7439         /* all options taking 'enum' */
   7440         case MHD_OPTION_HTTPS_CRED_TYPE:
   7441 #ifdef HTTPS_SUPPORT
   7442           if (MHD_NO == parse_options (daemon,
   7443                                        params,
   7444                                        opt,
   7445                                        (gnutls_credentials_type_t) oa[i].value,
   7446                                        MHD_OPTION_END))
   7447 #endif /* HTTPS_SUPPORT */
   7448           return MHD_NO;
   7449           break;
   7450         /* all options taking 'MHD_socket' */
   7451         case MHD_OPTION_LISTEN_SOCKET:
   7452           if (MHD_NO == parse_options (daemon,
   7453                                        params,
   7454                                        opt,
   7455                                        (MHD_socket) oa[i].value,
   7456                                        MHD_OPTION_END))
   7457             return MHD_NO;
   7458           break;
   7459         /* all options taking 'int' */
   7460         case MHD_OPTION_STRICT_FOR_CLIENT:
   7461         case MHD_OPTION_CLIENT_DISCIPLINE_LVL:
   7462         case MHD_OPTION_SIGPIPE_HANDLED_BY_APP:
   7463         case MHD_OPTION_TLS_NO_ALPN:
   7464         case MHD_OPTION_APP_FD_SETSIZE:
   7465         case MHD_OPTION_ALLOW_BIN_ZERO_IN_URI_PATH:
   7466           if (MHD_NO == parse_options (daemon,
   7467                                        params,
   7468                                        opt,
   7469                                        (int) oa[i].value,
   7470                                        MHD_OPTION_END))
   7471             return MHD_NO;
   7472           break;
   7473         /* all options taking 'uint32_t' */
   7474         case MHD_OPTION_DIGEST_AUTH_DEFAULT_MAX_NC:
   7475           if (MHD_NO == parse_options (daemon,
   7476                                        params,
   7477                                        opt,
   7478                                        (uint32_t) oa[i].value,
   7479                                        MHD_OPTION_END))
   7480             return MHD_NO;
   7481           break;
   7482         /* all options taking one pointer */
   7483         case MHD_OPTION_SOCK_ADDR:
   7484         case MHD_OPTION_HTTPS_MEM_KEY:
   7485         case MHD_OPTION_HTTPS_KEY_PASSWORD:
   7486         case MHD_OPTION_HTTPS_MEM_CERT:
   7487         case MHD_OPTION_HTTPS_MEM_TRUST:
   7488         case MHD_OPTION_HTTPS_MEM_DHPARAMS:
   7489         case MHD_OPTION_HTTPS_PRIORITIES:
   7490         case MHD_OPTION_HTTPS_PRIORITIES_APPEND:
   7491         case MHD_OPTION_ARRAY:
   7492         case MHD_OPTION_HTTPS_CERT_CALLBACK:
   7493         case MHD_OPTION_HTTPS_CERT_CALLBACK2:
   7494           if (MHD_NO == parse_options (daemon,
   7495                                        params,
   7496                                        opt,
   7497                                        oa[i].ptr_value,
   7498                                        MHD_OPTION_END))
   7499             return MHD_NO;
   7500           break;
   7501         /* all options taking two pointers */
   7502         case MHD_OPTION_NOTIFY_COMPLETED:
   7503         case MHD_OPTION_NOTIFY_CONNECTION:
   7504         case MHD_OPTION_URI_LOG_CALLBACK:
   7505         case MHD_OPTION_EXTERNAL_LOGGER:
   7506         case MHD_OPTION_UNESCAPE_CALLBACK:
   7507         case MHD_OPTION_GNUTLS_PSK_CRED_HANDLER:
   7508           if (MHD_NO == parse_options (daemon,
   7509                                        params,
   7510                                        opt,
   7511                                        (void *) oa[i].value,
   7512                                        oa[i].ptr_value,
   7513                                        MHD_OPTION_END))
   7514             return MHD_NO;
   7515           break;
   7516         /* options taking size_t-number followed by pointer */
   7517         case MHD_OPTION_DIGEST_AUTH_RANDOM:
   7518         case MHD_OPTION_DIGEST_AUTH_RANDOM_COPY:
   7519           if (MHD_NO == parse_options (daemon,
   7520                                        params,
   7521                                        opt,
   7522                                        (size_t) oa[i].value,
   7523                                        oa[i].ptr_value,
   7524                                        MHD_OPTION_END))
   7525             return MHD_NO;
   7526           break;
   7527         /* options taking socklen_t-number followed by pointer */
   7528         case MHD_OPTION_SOCK_ADDR_LEN:
   7529           if (MHD_NO == parse_options (daemon,
   7530                                        params,
   7531                                        opt,
   7532                                        (socklen_t) oa[i].value,
   7533                                        oa[i].ptr_value,
   7534                                        MHD_OPTION_END))
   7535             return MHD_NO;
   7536           break;
   7537         case MHD_OPTION_END: /* Not possible */
   7538         default:
   7539           return MHD_NO;
   7540         }
   7541         i++;
   7542       }
   7543       break;
   7544     case MHD_OPTION_UNESCAPE_CALLBACK:
   7545       daemon->unescape_callback = va_arg (ap,
   7546                                           UnescapeCallback);
   7547       daemon->unescape_callback_cls = va_arg (ap,
   7548                                               void *);
   7549       break;
   7550 #ifdef HTTPS_SUPPORT
   7551     case MHD_OPTION_GNUTLS_PSK_CRED_HANDLER:
   7552 #if GNUTLS_VERSION_MAJOR >= 3
   7553       daemon->cred_callback = va_arg (ap,
   7554                                       MHD_PskServerCredentialsCallback);
   7555       daemon->cred_callback_cls = va_arg (ap,
   7556                                           void *);
   7557       break;
   7558 #else
   7559       MHD_DLOG (daemon,
   7560                 _ ("MHD HTTPS option %d passed to MHD compiled " \
   7561                    "without GNUtls >= 3.\n"),
   7562                 opt);
   7563       return MHD_NO;
   7564 #endif
   7565 #endif /* HTTPS_SUPPORT */
   7566     case MHD_OPTION_SIGPIPE_HANDLED_BY_APP:
   7567       if (! MHD_D_IS_USING_THREADS_ (daemon))
   7568         daemon->sigpipe_blocked = ( (va_arg (ap,
   7569                                              int)) != 0);
   7570       else
   7571       {
   7572         (void) va_arg (ap,
   7573                        int);
   7574       }
   7575       break;
   7576     case MHD_OPTION_TLS_NO_ALPN:
   7577 #ifdef HTTPS_SUPPORT
   7578       daemon->disable_alpn = (va_arg (ap,
   7579                                       int) != 0);
   7580 #else  /* ! HTTPS_SUPPORT */
   7581       (void) va_arg (ap, int);
   7582 #endif /* ! HTTPS_SUPPORT */
   7583 #ifdef HAVE_MESSAGES
   7584       if (0 == (daemon->options & MHD_USE_TLS))
   7585         MHD_DLOG (daemon,
   7586                   _ ("MHD HTTPS option %d passed to MHD " \
   7587                      "but MHD_USE_TLS not set.\n"),
   7588                   (int) opt);
   7589 #endif /* HAVE_MESSAGES */
   7590       break;
   7591     case MHD_OPTION_APP_FD_SETSIZE:
   7592       params->fdset_size_set = true;
   7593       params->fdset_size = va_arg (ap,
   7594                                    int);
   7595       break;
   7596 #ifndef HTTPS_SUPPORT
   7597     case MHD_OPTION_HTTPS_MEM_KEY:
   7598     case MHD_OPTION_HTTPS_MEM_CERT:
   7599     case MHD_OPTION_HTTPS_CRED_TYPE:
   7600     case MHD_OPTION_HTTPS_PRIORITIES:
   7601     case MHD_OPTION_HTTPS_PRIORITIES_APPEND:
   7602     case MHD_OPTION_HTTPS_MEM_TRUST:
   7603     case MHD_OPTION_HTTPS_CERT_CALLBACK:
   7604     case MHD_OPTION_HTTPS_MEM_DHPARAMS:
   7605     case MHD_OPTION_HTTPS_KEY_PASSWORD:
   7606     case MHD_OPTION_GNUTLS_PSK_CRED_HANDLER:
   7607     case MHD_OPTION_HTTPS_CERT_CALLBACK2:
   7608 #ifdef HAVE_MESSAGES
   7609       MHD_DLOG (daemon,
   7610                 _ ("MHD HTTPS option %d passed to MHD "
   7611                    "compiled without HTTPS support.\n"),
   7612                 opt);
   7613 #endif
   7614       return MHD_NO;
   7615 #endif /* HTTPS_SUPPORT */
   7616     case MHD_OPTION_END: /* Not possible */
   7617     default:
   7618 #ifdef HAVE_MESSAGES
   7619       MHD_DLOG (daemon,
   7620                 _ ("Invalid option %d! (Did you terminate "
   7621                    "the list with MHD_OPTION_END?).\n"),
   7622                 opt);
   7623 #endif
   7624       return MHD_NO;
   7625     }
   7626   }
   7627   return MHD_YES;
   7628 }
   7629 
   7630 
   7631 #ifdef EPOLL_SUPPORT
   7632 static int
   7633 setup_epoll_fd (struct MHD_Daemon *daemon)
   7634 {
   7635   int fd;
   7636 
   7637 #ifndef HAVE_MESSAGES
   7638   (void) daemon; /* Mute compiler warning. */
   7639 #endif /* ! HAVE_MESSAGES */
   7640 
   7641 #ifdef USE_EPOLL_CREATE1
   7642   fd = epoll_create1 (EPOLL_CLOEXEC);
   7643 #else  /* ! USE_EPOLL_CREATE1 */
   7644   fd = epoll_create (MAX_EVENTS);
   7645 #endif /* ! USE_EPOLL_CREATE1 */
   7646   if (MHD_INVALID_SOCKET == fd)
   7647   {
   7648 #ifdef HAVE_MESSAGES
   7649     MHD_DLOG (daemon,
   7650               _ ("Call to epoll_create1 failed: %s\n"),
   7651               MHD_socket_last_strerr_ ());
   7652 #endif
   7653     return MHD_INVALID_SOCKET;
   7654   }
   7655 #if ! defined(USE_EPOLL_CREATE1)
   7656   if (! MHD_socket_noninheritable_ (fd))
   7657   {
   7658 #ifdef HAVE_MESSAGES
   7659     MHD_DLOG (daemon,
   7660               _ ("Failed to set noninheritable mode on epoll FD.\n"));
   7661 #endif
   7662   }
   7663 #endif /* ! USE_EPOLL_CREATE1 */
   7664   return fd;
   7665 }
   7666 
   7667 
   7668 /**
   7669  * Setup epoll() FD for the daemon and initialize it to listen
   7670  * on the listen FD.
   7671  * @remark To be called only from MHD_start_daemon_va()
   7672  *
   7673  * @param daemon daemon to initialize for epoll()
   7674  * @return #MHD_YES on success, #MHD_NO on failure
   7675  */
   7676 static enum MHD_Result
   7677 setup_epoll_to_listen (struct MHD_Daemon *daemon)
   7678 {
   7679   struct epoll_event event;
   7680   MHD_socket ls;
   7681 
   7682   mhd_assert (MHD_D_IS_USING_EPOLL_ (daemon));
   7683   mhd_assert (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION));
   7684   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   7685                (MHD_INVALID_SOCKET != (ls = daemon->listen_fd)) || \
   7686                MHD_ITC_IS_VALID_ (daemon->itc) );
   7687   daemon->epoll_fd = setup_epoll_fd (daemon);
   7688   if (! MHD_D_IS_USING_THREADS_ (daemon)
   7689       && (0 != (daemon->options & MHD_USE_AUTO)))
   7690   {
   7691     /* Application requested "MHD_USE_AUTO", probably MHD_get_fdset() will be
   7692        used.
   7693        Make sure that epoll FD is suitable for fd_set.
   7694        Actually, MHD_get_fdset() is allowed for MHD_USE_EPOLL direct,
   7695        but most probably direct requirement for MHD_USE_EPOLL means that
   7696        epoll FD will be used directly. This logic is fuzzy, but better
   7697        than nothing with current MHD API. */
   7698     if (! MHD_D_DOES_SCKT_FIT_FDSET_ (daemon->epoll_fd, daemon))
   7699     {
   7700 #ifdef HAVE_MESSAGES
   7701       MHD_DLOG (daemon,
   7702                 _ ("The epoll FD is too large to be used with fd_set.\n"));
   7703 #endif /* HAVE_MESSAGES */
   7704       return MHD_NO;
   7705     }
   7706   }
   7707   if (-1 == daemon->epoll_fd)
   7708     return MHD_NO;
   7709 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   7710   if (0 != (MHD_ALLOW_UPGRADE & daemon->options))
   7711   {
   7712     daemon->epoll_upgrade_fd = setup_epoll_fd (daemon);
   7713     if (MHD_INVALID_SOCKET == daemon->epoll_upgrade_fd)
   7714       return MHD_NO;
   7715   }
   7716 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   7717   if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_fd)) &&
   7718        (! daemon->was_quiesced) )
   7719   {
   7720     event.events = EPOLLIN | EPOLLRDHUP;
   7721     event.data.ptr = daemon;
   7722     if (0 != epoll_ctl (daemon->epoll_fd,
   7723                         EPOLL_CTL_ADD,
   7724                         ls,
   7725                         &event))
   7726     {
   7727 #ifdef HAVE_MESSAGES
   7728       MHD_DLOG (daemon,
   7729                 _ ("Call to epoll_ctl failed: %s\n"),
   7730                 MHD_socket_last_strerr_ ());
   7731 #endif
   7732       return MHD_NO;
   7733     }
   7734     daemon->listen_socket_in_epoll = true;
   7735   }
   7736 
   7737   if (MHD_ITC_IS_VALID_ (daemon->itc))
   7738   {
   7739     event.events = EPOLLIN | EPOLLRDHUP;
   7740     event.data.ptr = _MHD_DROP_CONST (epoll_itc_marker);
   7741     if (0 != epoll_ctl (daemon->epoll_fd,
   7742                         EPOLL_CTL_ADD,
   7743                         MHD_itc_r_fd_ (daemon->itc),
   7744                         &event))
   7745     {
   7746 #ifdef HAVE_MESSAGES
   7747       MHD_DLOG (daemon,
   7748                 _ ("Call to epoll_ctl failed: %s\n"),
   7749                 MHD_socket_last_strerr_ ());
   7750 #endif
   7751       return MHD_NO;
   7752     }
   7753   }
   7754   return MHD_YES;
   7755 }
   7756 
   7757 
   7758 #endif
   7759 
   7760 
   7761 /**
   7762  * Apply interim parameters
   7763  * @param[in,out] d the daemon to use
   7764  * @param[out] ppsockaddr the pointer to store the pointer to 'struct sockaddr'
   7765  *                        if provided by application
   7766  * @param[out] psockaddr_len the size memory area pointed by 'struct sockaddr'
   7767  *                           if provided by application
   7768  * @param[in,out] params the interim parameters to process
   7769  * @return true in case of success,
   7770  *         false in case of critical error (the daemon must be closed).
   7771  */
   7772 static bool
   7773 process_interim_params (struct MHD_Daemon *d,
   7774                         const struct sockaddr **ppsockaddr,
   7775                         socklen_t *psockaddr_len,
   7776                         struct MHD_InterimParams_ *params)
   7777 {
   7778   if (params->fdset_size_set)
   7779   {
   7780     if (0 >= params->fdset_size)
   7781     {
   7782 #ifdef HAVE_MESSAGES
   7783       MHD_DLOG (d,
   7784                 _ ("MHD_OPTION_APP_FD_SETSIZE value (%d) is not positive.\n"),
   7785                 params->fdset_size);
   7786 #endif /* HAVE_MESSAGES */
   7787       return false;
   7788     }
   7789     if (MHD_D_IS_USING_THREADS_ (d))
   7790     {
   7791 #ifdef HAVE_MESSAGES
   7792       MHD_DLOG (d,
   7793                 _ ("MHD_OPTION_APP_FD_SETSIZE is ignored for daemon started " \
   7794                    "with MHD_USE_INTERNAL_POLLING_THREAD.\n"));
   7795 #endif /* HAVE_MESSAGES */
   7796       (void) 0;
   7797     }
   7798     else if (MHD_D_IS_USING_POLL_ (d))
   7799     {
   7800 #ifdef HAVE_MESSAGES
   7801       MHD_DLOG (d,
   7802                 _ ("MHD_OPTION_APP_FD_SETSIZE is ignored for daemon started " \
   7803                    "with MHD_USE_POLL.\n"));
   7804 #endif /* HAVE_MESSAGES */
   7805       (void) 0;
   7806     }
   7807     else
   7808     { /* The daemon without internal threads, external sockets polling */
   7809 #ifndef HAS_FD_SETSIZE_OVERRIDABLE
   7810       if (((int) FD_SETSIZE) != params->fdset_size)
   7811       {
   7812 #ifdef HAVE_MESSAGES
   7813         MHD_DLOG (d,
   7814                   _ ("MHD_OPTION_APP_FD_SETSIZE value (%d) does not match " \
   7815                      "the platform FD_SETSIZE value (%d) and this platform " \
   7816                      "does not support overriding of FD_SETSIZE.\n"),
   7817                   params->fdset_size, (int) FD_SETSIZE);
   7818 #endif /* HAVE_MESSAGES */
   7819         return false;
   7820       }
   7821 #else  /* HAS_FD_SETSIZE_OVERRIDABLE */
   7822       d->fdset_size = params->fdset_size;
   7823       d->fdset_size_set_by_app = true;
   7824 #endif /* HAS_FD_SETSIZE_OVERRIDABLE */
   7825     }
   7826   }
   7827 
   7828   if (params->listen_fd_set)
   7829   {
   7830     if (MHD_INVALID_SOCKET == params->listen_fd)
   7831     {
   7832       (void) 0; /* Use MHD-created socket */
   7833     }
   7834 #ifdef HAS_SIGNED_SOCKET
   7835     else if (0 > params->listen_fd)
   7836     {
   7837 #ifdef HAVE_MESSAGES
   7838       MHD_DLOG (d,
   7839                 _ ("The value provided for MHD_OPTION_LISTEN_SOCKET " \
   7840                    "is invalid.\n"));
   7841 #endif /* HAVE_MESSAGES */
   7842       return false;
   7843     }
   7844 #endif /* HAS_SIGNED_SOCKET */
   7845     else if (0 != (d->options & MHD_USE_NO_LISTEN_SOCKET))
   7846     {
   7847 #ifdef HAVE_MESSAGES
   7848       MHD_DLOG (d,
   7849                 _ ("MHD_OPTION_LISTEN_SOCKET specified for daemon "
   7850                    "with MHD_USE_NO_LISTEN_SOCKET flag set.\n"));
   7851 #endif /* HAVE_MESSAGES */
   7852       (void) MHD_socket_close_ (params->listen_fd);
   7853       return false;
   7854     }
   7855     else
   7856     {
   7857       d->listen_fd = params->listen_fd;
   7858       d->listen_is_unix = _MHD_UNKNOWN;
   7859 #ifdef MHD_USE_GETSOCKNAME
   7860       d->port = 0;  /* Force use of autodetection */
   7861 #endif /* MHD_USE_GETSOCKNAME */
   7862     }
   7863   }
   7864 
   7865   mhd_assert (! params->server_addr_len_set || params->pserver_addr_set);
   7866   if (params->pserver_addr_set)
   7867   {
   7868     if (NULL == params->pserver_addr)
   7869     {
   7870       /* The size must be zero if set */
   7871       if (params->server_addr_len_set && (0 != params->server_addr_len))
   7872         return false;
   7873       /* Ignore parameter if it is NULL */
   7874     }
   7875     else if (MHD_INVALID_SOCKET != d->listen_fd)
   7876     {
   7877 #ifdef HAVE_MESSAGES
   7878       MHD_DLOG (d,
   7879                 _ ("MHD_OPTION_LISTEN_SOCKET cannot be used together with " \
   7880                    "MHD_OPTION_SOCK_ADDR_LEN or MHD_OPTION_SOCK_ADDR.\n"));
   7881 #endif /* HAVE_MESSAGES */
   7882       return false;
   7883     }
   7884     else if (0 != (d->options & MHD_USE_NO_LISTEN_SOCKET))
   7885     {
   7886 #ifdef HAVE_MESSAGES
   7887       MHD_DLOG (d,
   7888                 _ ("MHD_OPTION_SOCK_ADDR_LEN or MHD_OPTION_SOCK_ADDR " \
   7889                    "specified for daemon with MHD_USE_NO_LISTEN_SOCKET " \
   7890                    "flag set.\n"));
   7891 #endif /* HAVE_MESSAGES */
   7892       if (MHD_INVALID_SOCKET != d->listen_fd)
   7893       {
   7894         (void) MHD_socket_close_ (params->listen_fd);
   7895         params->listen_fd = MHD_INVALID_SOCKET;
   7896       }
   7897       return false;
   7898     }
   7899     else
   7900     {
   7901       *ppsockaddr = params->pserver_addr;
   7902       if (params->server_addr_len_set)
   7903       {
   7904         /* The size must be non-zero if set */
   7905         if (0 == params->server_addr_len)
   7906           return false;
   7907         *psockaddr_len = params->server_addr_len;
   7908       }
   7909       else
   7910         *psockaddr_len = 0;
   7911     }
   7912   }
   7913   return true;
   7914 }
   7915 
   7916 
   7917 /**
   7918  * Start a webserver on the given port.
   7919  *
   7920  * @param flags combination of `enum MHD_FLAG` values
   7921  * @param port port to bind to (in host byte order),
   7922  *        use '0' to bind to random free port,
   7923  *        ignored if #MHD_OPTION_SOCK_ADDR or
   7924  *        #MHD_OPTION_LISTEN_SOCKET is provided
   7925  *        or #MHD_USE_NO_LISTEN_SOCKET is specified
   7926  * @param apc callback to call to check which clients
   7927  *        will be allowed to connect; you can pass NULL
   7928  *        in which case connections from any IP will be
   7929  *        accepted
   7930  * @param apc_cls extra argument to @a apc
   7931  * @param dh handler called for all requests (repeatedly)
   7932  * @param dh_cls extra argument to @a dh
   7933  * @param ap list of options (type-value pairs,
   7934  *        terminated with #MHD_OPTION_END).
   7935  * @return NULL on error, handle to daemon on success
   7936  * @ingroup event
   7937  */
   7938 _MHD_EXTERN struct MHD_Daemon *
   7939 MHD_start_daemon_va (unsigned int flags,
   7940                      uint16_t port,
   7941                      MHD_AcceptPolicyCallback apc,
   7942                      void *apc_cls,
   7943                      MHD_AccessHandlerCallback dh,
   7944                      void *dh_cls,
   7945                      va_list ap)
   7946 {
   7947   const MHD_SCKT_OPT_BOOL_ on = 1;
   7948   struct MHD_Daemon *daemon;
   7949   const struct sockaddr *pservaddr = NULL;
   7950   socklen_t addrlen;
   7951 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   7952   unsigned int i;
   7953 #endif
   7954   enum MHD_FLAG eflags; /* same type as in MHD_Daemon */
   7955   enum MHD_FLAG *pflags;
   7956   struct MHD_InterimParams_ *interim_params;
   7957 
   7958   MHD_check_global_init_ ();
   7959   eflags = (enum MHD_FLAG) flags;
   7960   pflags = &eflags;
   7961 
   7962   if (0 != (*pflags & MHD_USE_THREAD_PER_CONNECTION))
   7963     *pflags |= MHD_USE_INTERNAL_POLLING_THREAD; /* Force enable, log warning later if needed */
   7964 
   7965 #ifndef HAVE_INET6
   7966   if (0 != (*pflags & MHD_USE_IPv6))
   7967     return NULL;
   7968 #endif
   7969 #ifndef HAVE_POLL
   7970   if (0 != (*pflags & MHD_USE_POLL))
   7971     return NULL;
   7972 #endif
   7973 #ifndef EPOLL_SUPPORT
   7974   if (0 != (*pflags & MHD_USE_EPOLL))
   7975     return NULL;
   7976 #endif /* ! EPOLL_SUPPORT */
   7977 #ifndef HTTPS_SUPPORT
   7978   if (0 != (*pflags & MHD_USE_TLS))
   7979     return NULL;
   7980 #endif /* ! HTTPS_SUPPORT */
   7981 #ifndef TCP_FASTOPEN
   7982   if (0 != (*pflags & MHD_USE_TCP_FASTOPEN))
   7983     return NULL;
   7984 #endif
   7985   if (0 != (*pflags & MHD_ALLOW_UPGRADE))
   7986   {
   7987 #ifdef UPGRADE_SUPPORT
   7988     *pflags |= MHD_ALLOW_SUSPEND_RESUME;
   7989 #else  /* ! UPGRADE_SUPPORT */
   7990     return NULL;
   7991 #endif /* ! UPGRADE_SUPPORT */
   7992   }
   7993 #ifdef MHD_USE_THREADS
   7994   if ((MHD_USE_NO_THREAD_SAFETY | MHD_USE_INTERNAL_POLLING_THREAD) ==
   7995       ((MHD_USE_NO_THREAD_SAFETY | MHD_USE_INTERNAL_POLLING_THREAD)
   7996        & *pflags))
   7997     return NULL; /* Cannot be thread-unsafe with multiple threads */
   7998 #else  /* ! MHD_USE_THREADS */
   7999   if (0 != (*pflags & MHD_USE_INTERNAL_POLLING_THREAD))
   8000     return NULL;
   8001 #endif /* ! MHD_USE_THREADS */
   8002 
   8003   if (NULL == dh)
   8004     return NULL;
   8005 
   8006   /* Check for invalid combinations of flags. */
   8007   if ((0 != (*pflags & MHD_USE_POLL)) && (0 != (*pflags & MHD_USE_EPOLL)))
   8008     return NULL;
   8009   if ((0 != (*pflags & MHD_USE_EPOLL)) &&
   8010       (0 != (*pflags & MHD_USE_THREAD_PER_CONNECTION)))
   8011     return NULL;
   8012   if ((0 != (*pflags & MHD_USE_POLL)) &&
   8013       (0 == (*pflags & (MHD_USE_INTERNAL_POLLING_THREAD
   8014                         | MHD_USE_THREAD_PER_CONNECTION))))
   8015     return NULL;
   8016   if ((0 != (*pflags & MHD_USE_AUTO)) &&
   8017       (0 != (*pflags & (MHD_USE_POLL | MHD_USE_EPOLL))))
   8018     return NULL;
   8019 
   8020   if (0 != (*pflags & MHD_USE_AUTO))
   8021   {
   8022 #if defined(EPOLL_SUPPORT) && defined(HAVE_POLL)
   8023     if (0 != (*pflags & MHD_USE_THREAD_PER_CONNECTION))
   8024       *pflags |= MHD_USE_POLL;
   8025     else
   8026       *pflags |= MHD_USE_EPOLL; /* Including "external select" mode */
   8027 #elif defined(HAVE_POLL)
   8028     if (0 != (*pflags & MHD_USE_INTERNAL_POLLING_THREAD))
   8029       *pflags |= MHD_USE_POLL; /* Including thread-per-connection */
   8030 #elif defined(EPOLL_SUPPORT)
   8031     if (0 == (*pflags & MHD_USE_THREAD_PER_CONNECTION))
   8032       *pflags |= MHD_USE_EPOLL; /* Including "external select" mode */
   8033 #else
   8034     /* No choice: use select() for any mode - do not modify flags */
   8035 #endif
   8036   }
   8037 
   8038   if (0 != (*pflags & MHD_USE_NO_THREAD_SAFETY))
   8039     *pflags = (*pflags & ~((enum MHD_FLAG) MHD_USE_ITC)); /* useless in single-threaded environment */
   8040   else if (0 != (*pflags & MHD_USE_INTERNAL_POLLING_THREAD))
   8041   {
   8042 #ifdef HAVE_LISTEN_SHUTDOWN
   8043     if (0 != (*pflags & MHD_USE_NO_LISTEN_SOCKET))
   8044 #endif
   8045     *pflags |= MHD_USE_ITC;       /* yes, must use ITC to signal thread */
   8046   }
   8047 
   8048   if (NULL == (daemon = MHD_calloc_ (1, sizeof (struct MHD_Daemon))))
   8049     return NULL;
   8050   interim_params = (struct MHD_InterimParams_ *) \
   8051                    MHD_calloc_ (1, sizeof (struct MHD_InterimParams_));
   8052   if (NULL == interim_params)
   8053   {
   8054     int err_num = errno;
   8055     free (daemon);
   8056     errno = err_num;
   8057     return NULL;
   8058   }
   8059 #ifdef EPOLL_SUPPORT
   8060   daemon->epoll_fd = -1;
   8061 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   8062   daemon->epoll_upgrade_fd = -1;
   8063 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   8064 #endif
   8065   /* try to open listen socket */
   8066 #ifdef HTTPS_SUPPORT
   8067   daemon->priority_cache = NULL;
   8068 #endif /* HTTPS_SUPPORT */
   8069   daemon->listen_fd = MHD_INVALID_SOCKET;
   8070   daemon->listen_is_unix = _MHD_NO;
   8071   daemon->listening_address_reuse = 0;
   8072   daemon->options = *pflags;
   8073   pflags = &daemon->options;
   8074   daemon->client_discipline = (0 != (*pflags & MHD_USE_PEDANTIC_CHECKS)) ?
   8075                               1 : 0;
   8076   daemon->port = port;
   8077   daemon->apc = apc;
   8078   daemon->apc_cls = apc_cls;
   8079   daemon->default_handler = dh;
   8080   daemon->default_handler_cls = dh_cls;
   8081   daemon->connections = 0;
   8082   daemon->connection_limit = MHD_MAX_CONNECTIONS_DEFAULT;
   8083   daemon->pool_size = MHD_POOL_SIZE_DEFAULT;
   8084   daemon->pool_increment = MHD_BUF_INC_SIZE;
   8085   daemon->unescape_callback = &unescape_wrapper;
   8086   daemon->connection_timeout_ms = 0;       /* no timeout */
   8087   MHD_itc_set_invalid_ (daemon->itc);
   8088 #ifdef MHD_USE_THREADS
   8089   MHD_thread_handle_ID_set_invalid_ (&daemon->tid);
   8090 #endif /* MHD_USE_THREADS */
   8091 #ifdef SOMAXCONN
   8092   daemon->listen_backlog_size = SOMAXCONN;
   8093 #else  /* !SOMAXCONN */
   8094   daemon->listen_backlog_size = 511; /* should be safe value */
   8095 #endif /* !SOMAXCONN */
   8096 #ifdef HAVE_MESSAGES
   8097   daemon->custom_error_log = &MHD_default_logger_;
   8098   daemon->custom_error_log_cls = stderr;
   8099 #endif
   8100 #ifndef MHD_WINSOCK_SOCKETS
   8101   daemon->sigpipe_blocked = false;
   8102 #else  /* MHD_WINSOCK_SOCKETS */
   8103   /* There is no SIGPIPE on W32, nothing to block. */
   8104   daemon->sigpipe_blocked = true;
   8105 #endif /* _WIN32 && ! __CYGWIN__ */
   8106 #if defined(_DEBUG) && defined(HAVE_ACCEPT4)
   8107   daemon->avoid_accept4 = false;
   8108 #endif /* _DEBUG */
   8109 #ifdef HAS_FD_SETSIZE_OVERRIDABLE
   8110   daemon->fdset_size = (int) FD_SETSIZE;
   8111   daemon->fdset_size_set_by_app = false;
   8112 #endif /* HAS_FD_SETSIZE_OVERRIDABLE */
   8113 
   8114 #ifdef DAUTH_SUPPORT
   8115   daemon->digest_auth_rand_size = 0;
   8116   daemon->digest_auth_random = NULL;
   8117   daemon->nonce_nc_size = 4; /* tiny */
   8118   daemon->dauth_def_nonce_timeout = MHD_DAUTH_DEF_TIMEOUT_;
   8119   daemon->dauth_def_max_nc = MHD_DAUTH_DEF_MAX_NC_;
   8120 #endif
   8121 #ifdef HTTPS_SUPPORT
   8122   if (0 != (*pflags & MHD_USE_TLS))
   8123   {
   8124     daemon->cred_type = GNUTLS_CRD_CERTIFICATE;
   8125   }
   8126 #endif /* HTTPS_SUPPORT */
   8127 
   8128   interim_params->num_opts = 0;
   8129   interim_params->fdset_size_set = false;
   8130   interim_params->fdset_size = 0;
   8131   interim_params->listen_fd_set = false;
   8132   interim_params->listen_fd = MHD_INVALID_SOCKET;
   8133   interim_params->pserver_addr_set = false;
   8134   interim_params->pserver_addr = NULL;
   8135   interim_params->server_addr_len_set = false;
   8136   interim_params->server_addr_len = 0;
   8137 
   8138   if (MHD_NO == parse_options_va (daemon,
   8139                                   interim_params,
   8140                                   ap))
   8141   {
   8142 #ifdef HTTPS_SUPPORT
   8143     tls_cleanup_failed_start (daemon);
   8144 #endif /* HTTPS_SUPPORT */
   8145     free (interim_params);
   8146     free (daemon);
   8147     return NULL;
   8148   }
   8149   if (! process_interim_params (daemon,
   8150                                 &pservaddr,
   8151                                 &addrlen,
   8152                                 interim_params))
   8153   {
   8154 #ifdef HTTPS_SUPPORT
   8155     tls_cleanup_failed_start (daemon);
   8156 #endif /* HTTPS_SUPPORT */
   8157     free (interim_params);
   8158     free (daemon);
   8159     return NULL;
   8160   }
   8161   free (interim_params);
   8162   interim_params = NULL;
   8163 #ifdef HTTPS_SUPPORT
   8164   if ((0 != (*pflags & MHD_USE_TLS))
   8165       && (NULL == daemon->priority_cache)
   8166       && ! daemon_tls_priorities_init_default (daemon))
   8167   {
   8168 #ifdef HAVE_MESSAGES
   8169     MHD_DLOG (daemon,
   8170               _ ("Failed to initialise GnuTLS priorities.\n"));
   8171 #endif /* HAVE_MESSAGES */
   8172     tls_cleanup_failed_start (daemon);
   8173     free (daemon);
   8174     return NULL;
   8175   }
   8176 #endif /* HTTPS_SUPPORT */
   8177 
   8178 #ifdef HAVE_MESSAGES
   8179   if ( (0 != (flags & MHD_USE_THREAD_PER_CONNECTION)) &&
   8180        (0 == (flags & MHD_USE_INTERNAL_POLLING_THREAD)) )
   8181   {
   8182     MHD_DLOG (daemon,
   8183               _ ("Warning: MHD_USE_THREAD_PER_CONNECTION must be used " \
   8184                  "only with MHD_USE_INTERNAL_POLLING_THREAD. " \
   8185                  "Flag MHD_USE_INTERNAL_POLLING_THREAD was added. " \
   8186                  "Consider setting MHD_USE_INTERNAL_POLLING_THREAD " \
   8187                  "explicitly.\n"));
   8188   }
   8189 #endif
   8190 
   8191   if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon)
   8192       && ((NULL != daemon->notify_completed)
   8193           || (NULL != daemon->notify_connection)) )
   8194     *pflags |= MHD_USE_ITC; /* requires ITC */
   8195 
   8196 #ifdef _DEBUG
   8197 #ifdef HAVE_MESSAGES
   8198   MHD_DLOG (daemon,
   8199             _ ("Using debug build of libmicrohttpd.\n") );
   8200 #endif /* HAVE_MESSAGES */
   8201 #endif /* _DEBUG */
   8202 
   8203   if ( (0 != (*pflags & MHD_USE_ITC))
   8204 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8205        && (0 == daemon->worker_pool_size)
   8206 #endif
   8207        )
   8208   {
   8209     if (! MHD_itc_init_ (daemon->itc))
   8210     {
   8211 #ifdef HAVE_MESSAGES
   8212       MHD_DLOG (daemon,
   8213                 _ ("Failed to create inter-thread communication channel: %s\n"),
   8214                 MHD_itc_last_strerror_ ());
   8215 #endif
   8216 #ifdef HTTPS_SUPPORT
   8217       if (NULL != daemon->priority_cache)
   8218         gnutls_priority_deinit (daemon->priority_cache);
   8219 #endif /* HTTPS_SUPPORT */
   8220       free (daemon);
   8221       return NULL;
   8222     }
   8223     if (MHD_D_IS_USING_SELECT_ (daemon) &&
   8224         (! MHD_D_DOES_SCKT_FIT_FDSET_ (MHD_itc_r_fd_ (daemon->itc), daemon)) )
   8225     {
   8226 #ifdef HAVE_MESSAGES
   8227       MHD_DLOG (daemon,
   8228                 _ ("file descriptor for inter-thread communication " \
   8229                    "channel exceeds maximum value.\n"));
   8230 #endif
   8231       MHD_itc_destroy_chk_ (daemon->itc);
   8232 #ifdef HTTPS_SUPPORT
   8233       if (NULL != daemon->priority_cache)
   8234         gnutls_priority_deinit (daemon->priority_cache);
   8235 #endif /* HTTPS_SUPPORT */
   8236       free (daemon);
   8237       return NULL;
   8238     }
   8239   }
   8240 
   8241 #ifdef DAUTH_SUPPORT
   8242   if (NULL != daemon->digest_auth_random_copy)
   8243   {
   8244     mhd_assert (daemon == daemon->digest_auth_random_copy);
   8245     daemon->digest_auth_random_copy = malloc (daemon->digest_auth_rand_size);
   8246     if (NULL == daemon->digest_auth_random_copy)
   8247     {
   8248 #ifdef HTTPS_SUPPORT
   8249       if (0 != (*pflags & MHD_USE_TLS))
   8250         gnutls_priority_deinit (daemon->priority_cache);
   8251 #endif /* HTTPS_SUPPORT */
   8252       free (daemon);
   8253       return NULL;
   8254     }
   8255     memcpy (daemon->digest_auth_random_copy,
   8256             daemon->digest_auth_random,
   8257             daemon->digest_auth_rand_size);
   8258     daemon->digest_auth_random = daemon->digest_auth_random_copy;
   8259   }
   8260   if (daemon->nonce_nc_size > 0)
   8261   {
   8262     if ( ( (size_t) (daemon->nonce_nc_size * sizeof (struct MHD_NonceNc)))
   8263          / sizeof(struct MHD_NonceNc) != daemon->nonce_nc_size)
   8264     {
   8265 #ifdef HAVE_MESSAGES
   8266       MHD_DLOG (daemon,
   8267                 _ ("Specified value for NC_SIZE too large.\n"));
   8268 #endif
   8269 #ifdef HTTPS_SUPPORT
   8270       if (0 != (*pflags & MHD_USE_TLS))
   8271         gnutls_priority_deinit (daemon->priority_cache);
   8272 #endif /* HTTPS_SUPPORT */
   8273       free (daemon->digest_auth_random_copy);
   8274       free (daemon);
   8275       return NULL;
   8276     }
   8277     daemon->nnc = MHD_calloc_ (daemon->nonce_nc_size,
   8278                                sizeof (struct MHD_NonceNc));
   8279     if (NULL == daemon->nnc)
   8280     {
   8281 #ifdef HAVE_MESSAGES
   8282       MHD_DLOG (daemon,
   8283                 _ ("Failed to allocate memory for nonce-nc map: %s\n"),
   8284                 MHD_strerror_ (errno));
   8285 #endif
   8286 #ifdef HTTPS_SUPPORT
   8287       if (0 != (*pflags & MHD_USE_TLS))
   8288         gnutls_priority_deinit (daemon->priority_cache);
   8289 #endif /* HTTPS_SUPPORT */
   8290       free (daemon->digest_auth_random_copy);
   8291       free (daemon);
   8292       return NULL;
   8293     }
   8294   }
   8295 
   8296 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8297   if (! MHD_mutex_init_ (&daemon->nnc_lock))
   8298   {
   8299 #ifdef HAVE_MESSAGES
   8300     MHD_DLOG (daemon,
   8301               _ ("MHD failed to initialize nonce-nc mutex.\n"));
   8302 #endif
   8303 #ifdef HTTPS_SUPPORT
   8304     if (0 != (*pflags & MHD_USE_TLS))
   8305       gnutls_priority_deinit (daemon->priority_cache);
   8306 #endif /* HTTPS_SUPPORT */
   8307     free (daemon->digest_auth_random_copy);
   8308     free (daemon->nnc);
   8309     free (daemon);
   8310     return NULL;
   8311   }
   8312 #endif
   8313 #endif
   8314 
   8315   /* Thread polling currently works only with internal select thread mode */
   8316 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8317   if ( (! MHD_D_IS_USING_THREADS_ (daemon)) &&
   8318        (daemon->worker_pool_size > 0) )
   8319   {
   8320 #ifdef HAVE_MESSAGES
   8321     MHD_DLOG (daemon,
   8322               _ ("MHD thread polling only works with " \
   8323                  "MHD_USE_INTERNAL_POLLING_THREAD.\n"));
   8324 #endif
   8325     goto free_and_fail;
   8326   }
   8327 #endif
   8328 
   8329   if ( (MHD_INVALID_SOCKET == daemon->listen_fd) &&
   8330        (0 == (*pflags & MHD_USE_NO_LISTEN_SOCKET)) )
   8331   {
   8332     /* try to open listen socket */
   8333     struct sockaddr_in servaddr4;
   8334 #ifdef HAVE_INET6
   8335     struct sockaddr_in6 servaddr6;
   8336     const bool use_ipv6 = (0 != (*pflags & MHD_USE_IPv6));
   8337 #else  /* ! HAVE_INET6 */
   8338     const bool use_ipv6 = false;
   8339 #endif /* ! HAVE_INET6 */
   8340     int domain;
   8341 
   8342     if (NULL != pservaddr)
   8343     {
   8344 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
   8345       const socklen_t sa_len = pservaddr->sa_len;
   8346 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
   8347 #ifdef HAVE_INET6
   8348       if (use_ipv6 && (AF_INET6 != pservaddr->sa_family))
   8349       {
   8350 #ifdef HAVE_MESSAGES
   8351         MHD_DLOG (daemon,
   8352                   _ ("MHD_USE_IPv6 is enabled, but 'struct sockaddr *' " \
   8353                      "specified for MHD_OPTION_SOCK_ADDR_LEN or " \
   8354                      "MHD_OPTION_SOCK_ADDR is not IPv6 address.\n"));
   8355 #endif /* HAVE_MESSAGES */
   8356         goto free_and_fail;
   8357       }
   8358 #endif /* HAVE_INET6 */
   8359       switch (pservaddr->sa_family)
   8360       {
   8361       case AF_INET:
   8362         if (1)
   8363         {
   8364           struct sockaddr_in sa4;
   8365           uint16_t sa4_port;
   8366           if ((0 != addrlen)
   8367               && (((socklen_t) sizeof(sa4)) > addrlen))
   8368           {
   8369 #ifdef HAVE_MESSAGES
   8370             MHD_DLOG (daemon,
   8371                       _ ("The size specified for MHD_OPTION_SOCK_ADDR_LEN " \
   8372                          "option is wrong.\n"));
   8373 #endif /* HAVE_MESSAGES */
   8374             goto free_and_fail;
   8375           }
   8376 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
   8377           if (0 != sa_len)
   8378           {
   8379             if (((socklen_t) sizeof(sa4)) > sa_len)
   8380             {
   8381 #ifdef HAVE_MESSAGES
   8382               MHD_DLOG (daemon,
   8383                         _ ("The value of 'struct sockaddr.sa_len' provided " \
   8384                            "via MHD_OPTION_SOCK_ADDR_LEN option is not zero " \
   8385                            "and does not match 'sa_family' value of the " \
   8386                            "same structure.\n"));
   8387 #endif /* HAVE_MESSAGES */
   8388               goto free_and_fail;
   8389             }
   8390             if ((0 == addrlen) || (sa_len < addrlen))
   8391               addrlen = sa_len; /* Use smaller value for safety */
   8392           }
   8393 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
   8394           if (0 == addrlen)
   8395             addrlen = sizeof(sa4);
   8396           memcpy (&sa4, pservaddr, sizeof(sa4));  /* Required due to stronger alignment */
   8397           sa4_port = (uint16_t) ntohs (sa4.sin_port);
   8398 #ifndef MHD_USE_GETSOCKNAME
   8399           if (0 != sa4_port)
   8400 #endif /* ! MHD_USE_GETSOCKNAME */
   8401           daemon->port = sa4_port;
   8402           domain = PF_INET;
   8403         }
   8404         break;
   8405 #ifdef HAVE_INET6
   8406       case AF_INET6:
   8407         if (1)
   8408         {
   8409           struct sockaddr_in6 sa6;
   8410           uint16_t sa6_port;
   8411           if ((0 != addrlen)
   8412               && (((socklen_t) sizeof(sa6)) > addrlen))
   8413           {
   8414 #ifdef HAVE_MESSAGES
   8415             MHD_DLOG (daemon,
   8416                       _ ("The size specified for MHD_OPTION_SOCK_ADDR_LEN " \
   8417                          "option is wrong.\n"));
   8418 #endif /* HAVE_MESSAGES */
   8419             goto free_and_fail;
   8420           }
   8421 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
   8422           if (0 != sa_len)
   8423           {
   8424             if (((socklen_t) sizeof(sa6)) > sa_len)
   8425             {
   8426 #ifdef HAVE_MESSAGES
   8427               MHD_DLOG (daemon,
   8428                         _ ("The value of 'struct sockaddr.sa_len' provided " \
   8429                            "via MHD_OPTION_SOCK_ADDR_LEN option is not zero " \
   8430                            "and does not match 'sa_family' value of the " \
   8431                            "same structure.\n"));
   8432 #endif /* HAVE_MESSAGES */
   8433               goto free_and_fail;
   8434             }
   8435             if ((0 == addrlen) || (sa_len < addrlen))
   8436               addrlen = sa_len; /* Use smaller value for safety */
   8437           }
   8438 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
   8439           if (0 == addrlen)
   8440             addrlen = sizeof(sa6);
   8441           memcpy (&sa6, pservaddr, sizeof(sa6));  /* Required due to stronger alignment */
   8442           sa6_port = (uint16_t) ntohs (sa6.sin6_port);
   8443 #ifndef MHD_USE_GETSOCKNAME
   8444           if (0 != sa6_port)
   8445 #endif /* ! MHD_USE_GETSOCKNAME */
   8446           daemon->port = sa6_port;
   8447           domain = PF_INET6;
   8448           *pflags |= ((enum MHD_FLAG) MHD_USE_IPv6);
   8449         }
   8450         break;
   8451 #endif /* HAVE_INET6 */
   8452 #ifdef AF_UNIX
   8453       case AF_UNIX:
   8454 #endif /* AF_UNIX */
   8455       default:
   8456 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
   8457         if (0 == addrlen)
   8458           addrlen = sa_len;
   8459         else if ((0 != sa_len) && (sa_len < addrlen))
   8460           addrlen = sa_len; /* Use smaller value for safety */
   8461 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
   8462         if (0 >= addrlen)
   8463         {
   8464 #ifdef HAVE_MESSAGES
   8465           MHD_DLOG (daemon,
   8466                     _ ("The 'sa_family' of the 'struct sockaddr' provided " \
   8467                        "via MHD_OPTION_SOCK_ADDR option is not supported.\n"));
   8468 #endif /* HAVE_MESSAGES */
   8469           goto free_and_fail;
   8470         }
   8471 #ifdef AF_UNIX
   8472         if (AF_UNIX == pservaddr->sa_family)
   8473         {
   8474           daemon->port = 0;     /* special value for UNIX domain sockets */
   8475           daemon->listen_is_unix = _MHD_YES;
   8476 #ifdef PF_UNIX
   8477           domain = PF_UNIX;
   8478 #else /* ! PF_UNIX */
   8479           domain = AF_UNIX;
   8480 #endif /* ! PF_UNIX */
   8481         }
   8482         else /* combined with the next 'if' */
   8483 #endif /* AF_UNIX */
   8484         if (1)
   8485         {
   8486           daemon->port = 0;     /* ugh */
   8487           daemon->listen_is_unix = _MHD_UNKNOWN;
   8488           /* Assumed the same values for AF_* and PF_* */
   8489           domain = pservaddr->sa_family;
   8490         }
   8491         break;
   8492       }
   8493     }
   8494     else
   8495     {
   8496       if (! use_ipv6)
   8497       {
   8498         memset (&servaddr4,
   8499                 0,
   8500                 sizeof (struct sockaddr_in));
   8501         servaddr4.sin_family = AF_INET;
   8502         servaddr4.sin_port = htons (port);
   8503         if (0 != INADDR_ANY)
   8504           servaddr4.sin_addr.s_addr = htonl (INADDR_ANY);
   8505 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
   8506         servaddr4.sin_len = sizeof (struct sockaddr_in);
   8507 #endif
   8508         pservaddr = (struct sockaddr *) &servaddr4;
   8509         addrlen = (socklen_t) sizeof(servaddr4);
   8510         daemon->listen_is_unix = _MHD_NO;
   8511         domain = PF_INET;
   8512       }
   8513 #ifdef HAVE_INET6
   8514       else
   8515       {
   8516 #ifdef IN6ADDR_ANY_INIT
   8517         static const struct in6_addr static_in6any = IN6ADDR_ANY_INIT;
   8518 #endif
   8519         memset (&servaddr6,
   8520                 0,
   8521                 sizeof (struct sockaddr_in6));
   8522         servaddr6.sin6_family = AF_INET6;
   8523         servaddr6.sin6_port = htons (port);
   8524 #ifdef IN6ADDR_ANY_INIT
   8525         servaddr6.sin6_addr = static_in6any;
   8526 #endif
   8527 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
   8528         servaddr6.sin6_len = sizeof (struct sockaddr_in6);
   8529 #endif
   8530         pservaddr = (struct sockaddr *) &servaddr6;
   8531         addrlen = (socklen_t) sizeof (servaddr6);
   8532         daemon->listen_is_unix = _MHD_NO;
   8533         domain = PF_INET6;
   8534       }
   8535 #endif /* HAVE_INET6 */
   8536     }
   8537 
   8538     daemon->listen_fd = MHD_socket_create_listen_ (domain);
   8539     if (MHD_INVALID_SOCKET == daemon->listen_fd)
   8540     {
   8541 #ifdef HAVE_MESSAGES
   8542       MHD_DLOG (daemon,
   8543                 _ ("Failed to create socket for listening: %s\n"),
   8544                 MHD_socket_last_strerr_ ());
   8545 #endif
   8546       goto free_and_fail;
   8547     }
   8548     if (MHD_D_IS_USING_SELECT_ (daemon) &&
   8549         (! MHD_D_DOES_SCKT_FIT_FDSET_ (daemon->listen_fd,
   8550                                        daemon)) )
   8551     {
   8552 #ifdef HAVE_MESSAGES
   8553       MHD_DLOG (daemon,
   8554                 _ ("Listen socket descriptor (%d) is not " \
   8555                    "less than daemon FD_SETSIZE value (%d).\n"),
   8556                 (int) daemon->listen_fd,
   8557                 (int) MHD_D_GET_FD_SETSIZE_ (daemon));
   8558 #endif
   8559       goto free_and_fail;
   8560     }
   8561 
   8562     /* Apply the socket options according to listening_address_reuse. */
   8563     if (0 == daemon->listening_address_reuse)
   8564     {
   8565 #ifndef MHD_WINSOCK_SOCKETS
   8566       /* No user requirement, use "traditional" default SO_REUSEADDR
   8567        * on non-W32 platforms, and do not fail if it doesn't work.
   8568        * Don't use it on W32, because on W32 it will allow multiple
   8569        * bind to the same address:port, like SO_REUSEPORT on others. */
   8570       if (0 > setsockopt (daemon->listen_fd,
   8571                           SOL_SOCKET,
   8572                           SO_REUSEADDR,
   8573                           (const void *) &on, sizeof (on)))
   8574       {
   8575 #ifdef HAVE_MESSAGES
   8576         MHD_DLOG (daemon,
   8577                   _ ("setsockopt failed: %s\n"),
   8578                   MHD_socket_last_strerr_ ());
   8579 #endif
   8580       }
   8581 #endif /* ! MHD_WINSOCK_SOCKETS */
   8582     }
   8583     else if (daemon->listening_address_reuse > 0)
   8584     {
   8585       /* User requested to allow reusing listening address:port. */
   8586 #ifndef MHD_WINSOCK_SOCKETS
   8587       /* Use SO_REUSEADDR on non-W32 platforms, and do not fail if
   8588        * it doesn't work. */
   8589       if (0 > setsockopt (daemon->listen_fd,
   8590                           SOL_SOCKET,
   8591                           SO_REUSEADDR,
   8592                           (const void *) &on, sizeof (on)))
   8593       {
   8594 #ifdef HAVE_MESSAGES
   8595         MHD_DLOG (daemon,
   8596                   _ ("setsockopt failed: %s\n"),
   8597                   MHD_socket_last_strerr_ ());
   8598 #endif
   8599       }
   8600 #endif /* ! MHD_WINSOCK_SOCKETS */
   8601       /* Use SO_REUSEADDR on Windows and SO_REUSEPORT on most platforms.
   8602        * Fail if SO_REUSEPORT is not defined or setsockopt fails.
   8603        */
   8604       /* SO_REUSEADDR on W32 has the same semantics
   8605          as SO_REUSEPORT on BSD/Linux */
   8606 #if defined(MHD_WINSOCK_SOCKETS) || defined(SO_REUSEPORT)
   8607       if (0 > setsockopt (daemon->listen_fd,
   8608                           SOL_SOCKET,
   8609 #ifndef MHD_WINSOCK_SOCKETS
   8610                           SO_REUSEPORT,
   8611 #else  /* MHD_WINSOCK_SOCKETS */
   8612                           SO_REUSEADDR,
   8613 #endif /* MHD_WINSOCK_SOCKETS */
   8614                           (const void *) &on,
   8615                           sizeof (on)))
   8616       {
   8617 #ifdef HAVE_MESSAGES
   8618         MHD_DLOG (daemon,
   8619                   _ ("setsockopt failed: %s\n"),
   8620                   MHD_socket_last_strerr_ ());
   8621 #endif
   8622         goto free_and_fail;
   8623       }
   8624 #else  /* !MHD_WINSOCK_SOCKETS && !SO_REUSEPORT */
   8625       /* we're supposed to allow address:port re-use, but
   8626          on this platform we cannot; fail hard */
   8627 #ifdef HAVE_MESSAGES
   8628       MHD_DLOG (daemon,
   8629                 _ ("Cannot allow listening address reuse: " \
   8630                    "SO_REUSEPORT not defined.\n"));
   8631 #endif
   8632       goto free_and_fail;
   8633 #endif /* !MHD_WINSOCK_SOCKETS && !SO_REUSEPORT */
   8634     }
   8635     else   /* if (daemon->listening_address_reuse < 0) */
   8636     {
   8637       /* User requested to disallow reusing listening address:port.
   8638        * Do nothing except for Windows where SO_EXCLUSIVEADDRUSE
   8639        * is used and Solaris with SO_EXCLBIND.
   8640        * Fail if MHD was compiled for W32 without SO_EXCLUSIVEADDRUSE
   8641        * or setsockopt fails.
   8642        */
   8643 #if (defined(MHD_WINSOCK_SOCKETS) && defined(SO_EXCLUSIVEADDRUSE)) || \
   8644       (defined(__sun) && defined(SO_EXCLBIND))
   8645       if (0 > setsockopt (daemon->listen_fd,
   8646                           SOL_SOCKET,
   8647 #ifdef SO_EXCLUSIVEADDRUSE
   8648                           SO_EXCLUSIVEADDRUSE,
   8649 #else  /* SO_EXCLBIND */
   8650                           SO_EXCLBIND,
   8651 #endif /* SO_EXCLBIND */
   8652                           (const void *) &on,
   8653                           sizeof (on)))
   8654       {
   8655 #ifdef HAVE_MESSAGES
   8656         MHD_DLOG (daemon,
   8657                   _ ("setsockopt failed: %s\n"),
   8658                   MHD_socket_last_strerr_ ());
   8659 #endif
   8660         goto free_and_fail;
   8661       }
   8662 #elif defined(MHD_WINSOCK_SOCKETS) /* SO_EXCLUSIVEADDRUSE not defined on W32? */
   8663 #ifdef HAVE_MESSAGES
   8664       MHD_DLOG (daemon,
   8665                 _ ("Cannot disallow listening address reuse: " \
   8666                    "SO_EXCLUSIVEADDRUSE not defined.\n"));
   8667 #endif
   8668       goto free_and_fail;
   8669 #endif /* MHD_WINSOCK_SOCKETS */
   8670     }
   8671 
   8672     /* check for user supplied sockaddr */
   8673     if (0 != (*pflags & MHD_USE_IPv6))
   8674     {
   8675 #ifdef IPPROTO_IPV6
   8676 #ifdef IPV6_V6ONLY
   8677       /* Note: "IPV6_V6ONLY" is declared by Windows Vista ff., see "IPPROTO_IPV6 Socket Options"
   8678          (http://msdn.microsoft.com/en-us/library/ms738574%28v=VS.85%29.aspx);
   8679          and may also be missing on older POSIX systems; good luck if you have any of those,
   8680          your IPv6 socket may then also bind against IPv4 anyway... */
   8681       const MHD_SCKT_OPT_BOOL_ v6_only =
   8682         (MHD_USE_DUAL_STACK != (*pflags & MHD_USE_DUAL_STACK));
   8683       if (0 > setsockopt (daemon->listen_fd,
   8684                           IPPROTO_IPV6, IPV6_V6ONLY,
   8685                           (const void *) &v6_only,
   8686                           sizeof (v6_only)))
   8687       {
   8688 #ifdef HAVE_MESSAGES
   8689         MHD_DLOG (daemon,
   8690                   _ ("setsockopt failed: %s\n"),
   8691                   MHD_socket_last_strerr_ ());
   8692 #endif
   8693       }
   8694 #endif
   8695 #endif
   8696     }
   8697     if (0 != bind (daemon->listen_fd,
   8698                    pservaddr,
   8699                    addrlen))
   8700     {
   8701 #ifdef HAVE_MESSAGES
   8702       MHD_DLOG (daemon,
   8703                 _ ("Failed to bind to port %u: %s\n"),
   8704                 (unsigned int) port,
   8705                 MHD_socket_last_strerr_ ());
   8706 #endif
   8707       goto free_and_fail;
   8708     }
   8709 #ifdef TCP_FASTOPEN
   8710     if (0 != (*pflags & MHD_USE_TCP_FASTOPEN))
   8711     {
   8712       if (0 == daemon->fastopen_queue_size)
   8713         daemon->fastopen_queue_size = MHD_TCP_FASTOPEN_QUEUE_SIZE_DEFAULT;
   8714       if (0 != setsockopt (daemon->listen_fd,
   8715                            IPPROTO_TCP,
   8716                            TCP_FASTOPEN,
   8717                            (const void *) &daemon->fastopen_queue_size,
   8718                            sizeof (daemon->fastopen_queue_size)))
   8719       {
   8720 #ifdef HAVE_MESSAGES
   8721         MHD_DLOG (daemon,
   8722                   _ ("setsockopt failed: %s\n"),
   8723                   MHD_socket_last_strerr_ ());
   8724 #endif
   8725       }
   8726     }
   8727 #endif
   8728     if (0 != listen (daemon->listen_fd,
   8729                      (int) daemon->listen_backlog_size))
   8730     {
   8731 #ifdef HAVE_MESSAGES
   8732       MHD_DLOG (daemon,
   8733                 _ ("Failed to listen for connections: %s\n"),
   8734                 MHD_socket_last_strerr_ ());
   8735 #endif
   8736       goto free_and_fail;
   8737     }
   8738   }
   8739   else
   8740   {
   8741     if (MHD_D_IS_USING_SELECT_ (daemon) &&
   8742         (! MHD_D_DOES_SCKT_FIT_FDSET_ (daemon->listen_fd,
   8743                                        daemon)) )
   8744     {
   8745 #ifdef HAVE_MESSAGES
   8746       MHD_DLOG (daemon,
   8747                 _ ("Listen socket descriptor (%d) is not " \
   8748                    "less than daemon FD_SETSIZE value (%d).\n"),
   8749                 (int) daemon->listen_fd,
   8750                 (int) MHD_D_GET_FD_SETSIZE_ (daemon));
   8751 #endif
   8752       goto free_and_fail;
   8753     }
   8754     else
   8755     {
   8756 #if defined(SOL_SOCKET) && (defined(SO_DOMAIN) || defined(SO_PROTOCOL_INFOW))
   8757       int af;
   8758       int opt_name;
   8759       void *poptval;
   8760       socklen_t optval_size;
   8761 #ifdef SO_DOMAIN
   8762       opt_name = SO_DOMAIN;
   8763       poptval = &af;
   8764       optval_size = (socklen_t) sizeof (af);
   8765 #else  /* SO_PROTOCOL_INFOW */
   8766       WSAPROTOCOL_INFOW prot_info;
   8767       opt_name = SO_PROTOCOL_INFOW;
   8768       poptval = &prot_info;
   8769       optval_size = (socklen_t) sizeof (prot_info);
   8770 #endif /* SO_PROTOCOL_INFOW */
   8771 
   8772       if (0 == getsockopt (daemon->listen_fd,
   8773                            SOL_SOCKET,
   8774                            opt_name,
   8775                            poptval,
   8776                            &optval_size))
   8777       {
   8778 #ifndef SO_DOMAIN
   8779         af = prot_info.iAddressFamily;
   8780 #endif /* SO_DOMAIN */
   8781         switch (af)
   8782         {
   8783         case AF_INET:
   8784           daemon->listen_is_unix = _MHD_NO;
   8785           break;
   8786 #ifdef HAVE_INET6
   8787         case AF_INET6:
   8788           *pflags |= MHD_USE_IPv6;
   8789           daemon->listen_is_unix = _MHD_NO;
   8790           break;
   8791 #endif /* HAVE_INET6 */
   8792 #ifdef AF_UNIX
   8793         case AF_UNIX:
   8794           daemon->port = 0;     /* special value for UNIX domain sockets */
   8795           daemon->listen_is_unix = _MHD_YES;
   8796           break;
   8797 #endif /* AF_UNIX */
   8798         default:
   8799           daemon->port = 0;     /* ugh */
   8800           daemon->listen_is_unix = _MHD_UNKNOWN;
   8801           break;
   8802         }
   8803       }
   8804       else
   8805 #endif /* SOL_SOCKET && (SO_DOMAIN || SO_PROTOCOL_INFOW)) */
   8806       daemon->listen_is_unix = _MHD_UNKNOWN;
   8807     }
   8808 
   8809 #ifdef MHD_USE_GETSOCKNAME
   8810     daemon->port = 0;  /* Force use of autodetection */
   8811 #endif /* MHD_USE_GETSOCKNAME */
   8812   }
   8813 
   8814 #ifdef MHD_USE_GETSOCKNAME
   8815   if ( (0 == daemon->port) &&
   8816        (0 == (*pflags & MHD_USE_NO_LISTEN_SOCKET)) &&
   8817        (_MHD_YES != daemon->listen_is_unix) )
   8818   {   /* Get port number. */
   8819     struct sockaddr_storage bindaddr;
   8820 
   8821     memset (&bindaddr,
   8822             0,
   8823             sizeof (struct sockaddr_storage));
   8824     addrlen = sizeof (struct sockaddr_storage);
   8825 #ifdef HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN
   8826     bindaddr.ss_len = (socklen_t) addrlen;
   8827 #endif
   8828     if (0 != getsockname (daemon->listen_fd,
   8829                           (struct sockaddr *) &bindaddr,
   8830                           &addrlen))
   8831     {
   8832 #ifdef HAVE_MESSAGES
   8833       MHD_DLOG (daemon,
   8834                 _ ("Failed to get listen port number: %s\n"),
   8835                 MHD_socket_last_strerr_ ());
   8836 #endif /* HAVE_MESSAGES */
   8837     }
   8838 #ifdef MHD_POSIX_SOCKETS
   8839     else if (sizeof (bindaddr) < addrlen)
   8840     {
   8841       /* should be impossible with `struct sockaddr_storage` */
   8842 #ifdef HAVE_MESSAGES
   8843       MHD_DLOG (daemon,
   8844                 _ ("Failed to get listen port number " \
   8845                    "(`struct sockaddr_storage` too small!?).\n"));
   8846 #endif /* HAVE_MESSAGES */
   8847     }
   8848 #ifndef __linux__
   8849     else if (0 == addrlen)
   8850     {
   8851       /* Many non-Linux-based platforms return zero addrlen
   8852        * for AF_UNIX sockets */
   8853       daemon->port = 0;     /* special value for UNIX domain sockets */
   8854       if (_MHD_UNKNOWN == daemon->listen_is_unix)
   8855         daemon->listen_is_unix = _MHD_YES;
   8856     }
   8857 #endif /* __linux__ */
   8858 #endif /* MHD_POSIX_SOCKETS */
   8859     else
   8860     {
   8861       switch (bindaddr.ss_family)
   8862       {
   8863       case AF_INET:
   8864         {
   8865           struct sockaddr_in *s4 = (struct sockaddr_in *) &bindaddr;
   8866 
   8867           daemon->port = ntohs (s4->sin_port);
   8868           daemon->listen_is_unix = _MHD_NO;
   8869           break;
   8870         }
   8871 #ifdef HAVE_INET6
   8872       case AF_INET6:
   8873         {
   8874           struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &bindaddr;
   8875 
   8876           daemon->port = ntohs (s6->sin6_port);
   8877           daemon->listen_is_unix = _MHD_NO;
   8878           mhd_assert (0 != (*pflags & MHD_USE_IPv6));
   8879           break;
   8880         }
   8881 #endif /* HAVE_INET6 */
   8882 #ifdef AF_UNIX
   8883       case AF_UNIX:
   8884         daemon->port = 0;     /* special value for UNIX domain sockets */
   8885         daemon->listen_is_unix = _MHD_YES;
   8886         break;
   8887 #endif
   8888       default:
   8889 #ifdef HAVE_MESSAGES
   8890         MHD_DLOG (daemon,
   8891                   _ ("Listen socket has unknown address family!\n"));
   8892 #endif
   8893         daemon->port = 0;     /* ugh */
   8894         daemon->listen_is_unix = _MHD_UNKNOWN;
   8895         break;
   8896       }
   8897     }
   8898   }
   8899 #endif /* MHD_USE_GETSOCKNAME */
   8900 
   8901   if (MHD_INVALID_SOCKET != daemon->listen_fd)
   8902   {
   8903     mhd_assert (0 == (*pflags & MHD_USE_NO_LISTEN_SOCKET));
   8904     if (! MHD_socket_nonblocking_ (daemon->listen_fd))
   8905     {
   8906 #ifdef HAVE_MESSAGES
   8907       MHD_DLOG (daemon,
   8908                 _ ("Failed to set nonblocking mode on listening socket: %s\n"),
   8909                 MHD_socket_last_strerr_ ());
   8910 #endif
   8911       if (MHD_D_IS_USING_EPOLL_ (daemon)
   8912 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8913           || (daemon->worker_pool_size > 0)
   8914 #endif
   8915           )
   8916       {
   8917         /* Accept must be non-blocking. Multiple children may wake up
   8918          * to handle a new connection, but only one will win the race.
   8919          * The others must immediately return. */
   8920         goto free_and_fail;
   8921       }
   8922       daemon->listen_nonblk = false;
   8923     }
   8924     else
   8925       daemon->listen_nonblk = true;
   8926   }
   8927   else
   8928   {
   8929     mhd_assert (0 != (*pflags & MHD_USE_NO_LISTEN_SOCKET));
   8930     daemon->listen_nonblk = false; /* Actually listen socket does not exist */
   8931   }
   8932 
   8933 #ifdef EPOLL_SUPPORT
   8934   if (MHD_D_IS_USING_EPOLL_ (daemon)
   8935 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8936       && (0 == daemon->worker_pool_size)
   8937 #endif
   8938       )
   8939   {
   8940     if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon))
   8941     {
   8942 #ifdef HAVE_MESSAGES
   8943       MHD_DLOG (daemon,
   8944                 _ ("Combining MHD_USE_THREAD_PER_CONNECTION and " \
   8945                    "MHD_USE_EPOLL is not supported.\n"));
   8946 #endif
   8947       goto free_and_fail;
   8948     }
   8949     if (MHD_NO == setup_epoll_to_listen (daemon))
   8950       goto free_and_fail;
   8951   }
   8952 #endif /* EPOLL_SUPPORT */
   8953 
   8954 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8955   if (! MHD_mutex_init_ (&daemon->per_ip_connection_mutex))
   8956   {
   8957 #ifdef HAVE_MESSAGES
   8958     MHD_DLOG (daemon,
   8959               _ ("MHD failed to initialize IP connection limit mutex.\n"));
   8960 #endif
   8961     goto free_and_fail;
   8962   }
   8963 #endif
   8964 
   8965 #ifdef HTTPS_SUPPORT
   8966   /* initialize HTTPS daemon certificate aspects & send / recv functions */
   8967   if ( (0 != (*pflags & MHD_USE_TLS)) &&
   8968        (0 != MHD_TLS_init (daemon)) )
   8969   {
   8970 #ifdef HAVE_MESSAGES
   8971     MHD_DLOG (daemon,
   8972               _ ("Failed to initialize TLS support.\n"));
   8973 #endif
   8974 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8975     MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   8976 #endif
   8977     goto free_and_fail;
   8978   }
   8979 #endif /* HTTPS_SUPPORT */
   8980 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   8981   /* Start threads if requested by parameters */
   8982   if (MHD_D_IS_USING_THREADS_ (daemon))
   8983   {
   8984     /* Internal thread (or threads) is used.
   8985      * Make sure that MHD will be able to communicate with threads. */
   8986     /* If using a thread pool ITC will be initialised later
   8987      * for each individual worker thread. */
   8988 #ifdef HAVE_LISTEN_SHUTDOWN
   8989     mhd_assert ((1 < daemon->worker_pool_size) || \
   8990                 (MHD_ITC_IS_VALID_ (daemon->itc)) || \
   8991                 (MHD_INVALID_SOCKET != daemon->listen_fd));
   8992 #else  /* ! HAVE_LISTEN_SHUTDOWN */
   8993     mhd_assert ((1 < daemon->worker_pool_size) || \
   8994                 (MHD_ITC_IS_VALID_ (daemon->itc)));
   8995 #endif /* ! HAVE_LISTEN_SHUTDOWN */
   8996     if (0 == daemon->worker_pool_size)
   8997     {
   8998       if (! MHD_mutex_init_ (&daemon->cleanup_connection_mutex))
   8999       {
   9000 #ifdef HAVE_MESSAGES
   9001         MHD_DLOG (daemon,
   9002                   _ ("Failed to initialise internal lists mutex.\n"));
   9003 #endif
   9004         MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9005         goto free_and_fail;
   9006       }
   9007       if (! MHD_mutex_init_ (&daemon->new_connections_mutex))
   9008       {
   9009 #ifdef HAVE_MESSAGES
   9010         MHD_DLOG (daemon,
   9011                   _ ("Failed to initialise mutex.\n"));
   9012 #endif
   9013         MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9014         MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
   9015         goto free_and_fail;
   9016       }
   9017       if (! MHD_mutex_init_ (&daemon->epoll_listen_mutex))
   9018       {
   9019 #ifdef HAVE_MESSAGES
   9020         MHD_DLOG (daemon,
   9021                   _ ("Failed to initialise mutex.\n"));
   9022 #endif
   9023         MHD_mutex_destroy_chk_ (&daemon->new_connections_mutex);
   9024         MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
   9025         MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9026         goto free_and_fail;
   9027       }
   9028       if (! MHD_create_named_thread_ (&daemon->tid,
   9029                                       MHD_D_IS_USING_THREAD_PER_CONN_ (daemon) ?
   9030                                       "MHD-listen" : "MHD-single",
   9031                                       daemon->thread_stack_size,
   9032                                       &MHD_polling_thread,
   9033                                       daemon) )
   9034       {
   9035 #ifdef HAVE_MESSAGES
   9036 #ifdef EAGAIN
   9037         if (EAGAIN == errno)
   9038           MHD_DLOG (daemon,
   9039                     _ ("Failed to create a new thread because it would have " \
   9040                        "exceeded the system limit on the number of threads or " \
   9041                        "no system resources available.\n"));
   9042         else
   9043 #endif /* EAGAIN */
   9044         MHD_DLOG (daemon,
   9045                   _ ("Failed to create listen thread: %s\n"),
   9046                   MHD_strerror_ (errno));
   9047 #endif /* HAVE_MESSAGES */
   9048         MHD_mutex_destroy_chk_ (&daemon->epoll_listen_mutex);
   9049         MHD_mutex_destroy_chk_ (&daemon->new_connections_mutex);
   9050         MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9051         MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
   9052         goto free_and_fail;
   9053       }
   9054     }
   9055     else   /* 0 < daemon->worker_pool_size */
   9056     {
   9057       /* Coarse-grained count of connections per thread (note error
   9058        * due to integer division). Also keep track of how many
   9059        * connections are leftover after an equal split. */
   9060       unsigned int conns_per_thread = daemon->connection_limit
   9061                                       / daemon->worker_pool_size;
   9062       unsigned int leftover_conns = daemon->connection_limit
   9063                                     % daemon->worker_pool_size;
   9064 
   9065       mhd_assert (2 <= daemon->worker_pool_size);
   9066       i = 0;     /* we need this in case fcntl or malloc fails */
   9067 
   9068       /* Allocate memory for pooled objects */
   9069       daemon->worker_pool = malloc (sizeof (struct MHD_Daemon)
   9070                                     * daemon->worker_pool_size);
   9071       if (NULL == daemon->worker_pool)
   9072         goto thread_failed;
   9073 
   9074       /* Start the workers in the pool */
   9075       for (i = 0; i < daemon->worker_pool_size; ++i)
   9076       {
   9077         /* Create copy of the Daemon object for each worker */
   9078         struct MHD_Daemon *d = &daemon->worker_pool[i];
   9079 
   9080         memcpy (d, daemon, sizeof (struct MHD_Daemon));
   9081         /* Adjust polling params for worker daemons; note that memcpy()
   9082            has already copied MHD_USE_INTERNAL_POLLING_THREAD thread mode into
   9083            the worker threads. */
   9084         d->master = daemon;
   9085         d->worker_pool_size = 0;
   9086         d->worker_pool = NULL;
   9087         if (! MHD_mutex_init_ (&d->cleanup_connection_mutex))
   9088         {
   9089 #ifdef HAVE_MESSAGES
   9090           MHD_DLOG (daemon,
   9091                     _ ("Failed to initialise internal lists mutex.\n"));
   9092 #endif
   9093           goto thread_failed;
   9094         }
   9095         if (! MHD_mutex_init_ (&d->new_connections_mutex))
   9096         {
   9097 #ifdef HAVE_MESSAGES
   9098           MHD_DLOG (daemon,
   9099                     _ ("Failed to initialise mutex.\n"));
   9100 #endif
   9101           MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
   9102           goto thread_failed;
   9103         }
   9104         if (! MHD_mutex_init_ (&d->epoll_listen_mutex))
   9105         {
   9106 #ifdef HAVE_MESSAGES
   9107           MHD_DLOG (daemon,
   9108                     _ ("Failed to initialise mutex.\n"));
   9109 #endif
   9110           MHD_mutex_destroy_chk_ (&d->new_connections_mutex);
   9111           MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
   9112           MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9113           goto free_and_fail;
   9114         }
   9115         if (0 != (*pflags & MHD_USE_ITC))
   9116         {
   9117           if (! MHD_itc_init_ (d->itc))
   9118           {
   9119 #ifdef HAVE_MESSAGES
   9120             MHD_DLOG (daemon,
   9121                       _ ("Failed to create worker inter-thread " \
   9122                          "communication channel: %s\n"),
   9123                       MHD_itc_last_strerror_ () );
   9124 #endif
   9125             MHD_mutex_destroy_chk_ (&d->epoll_listen_mutex);
   9126             MHD_mutex_destroy_chk_ (&d->new_connections_mutex);
   9127             MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
   9128             goto thread_failed;
   9129           }
   9130           if (MHD_D_IS_USING_SELECT_ (d) &&
   9131               (! MHD_D_DOES_SCKT_FIT_FDSET_ (MHD_itc_r_fd_ (d->itc), daemon)) )
   9132           {
   9133 #ifdef HAVE_MESSAGES
   9134             MHD_DLOG (daemon,
   9135                       _ ("File descriptor for worker inter-thread " \
   9136                          "communication channel exceeds maximum value.\n"));
   9137 #endif
   9138             MHD_itc_destroy_chk_ (d->itc);
   9139             MHD_mutex_destroy_chk_ (&d->epoll_listen_mutex);
   9140             MHD_mutex_destroy_chk_ (&d->new_connections_mutex);
   9141             MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
   9142             goto thread_failed;
   9143           }
   9144         }
   9145         else
   9146           MHD_itc_set_invalid_ (d->itc);
   9147 
   9148 #ifdef HAVE_LISTEN_SHUTDOWN
   9149         mhd_assert ((MHD_ITC_IS_VALID_ (d->itc)) || \
   9150                     (MHD_INVALID_SOCKET != d->listen_fd));
   9151 #else  /* ! HAVE_LISTEN_SHUTDOWN */
   9152         mhd_assert (MHD_ITC_IS_VALID_ (d->itc));
   9153 #endif /* ! HAVE_LISTEN_SHUTDOWN */
   9154 
   9155         /* Divide available connections evenly amongst the threads.
   9156          * Thread indexes in [0, leftover_conns) each get one of the
   9157          * leftover connections. */
   9158         d->connection_limit = conns_per_thread;
   9159         if (i < leftover_conns)
   9160           ++d->connection_limit;
   9161 #ifdef EPOLL_SUPPORT
   9162         if (MHD_D_IS_USING_EPOLL_ (d) &&
   9163             (MHD_NO == setup_epoll_to_listen (d)) )
   9164         {
   9165           if (MHD_ITC_IS_VALID_ (d->itc))
   9166             MHD_itc_destroy_chk_ (d->itc);
   9167           MHD_mutex_destroy_chk_ (&d->epoll_listen_mutex);
   9168           MHD_mutex_destroy_chk_ (&d->new_connections_mutex);
   9169           MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
   9170           goto thread_failed;
   9171         }
   9172 #endif
   9173         /* Some members must be used only in master daemon */
   9174 #if defined(MHD_USE_THREADS)
   9175         memset (&d->per_ip_connection_mutex, 0x7F,
   9176                 sizeof(d->per_ip_connection_mutex));
   9177 #endif /* MHD_USE_THREADS */
   9178 #ifdef DAUTH_SUPPORT
   9179         d->nnc = NULL;
   9180         d->nonce_nc_size = 0;
   9181         d->digest_auth_random_copy = NULL;
   9182 #if defined(MHD_USE_THREADS)
   9183         memset (&d->nnc_lock, 0x7F, sizeof(d->nnc_lock));
   9184 #endif /* MHD_USE_THREADS */
   9185 #endif /* DAUTH_SUPPORT */
   9186 
   9187         /* Spawn the worker thread */
   9188         if (! MHD_create_named_thread_ (&d->tid,
   9189                                         "MHD-worker",
   9190                                         daemon->thread_stack_size,
   9191                                         &MHD_polling_thread,
   9192                                         d))
   9193         {
   9194 #ifdef HAVE_MESSAGES
   9195 #ifdef EAGAIN
   9196           if (EAGAIN == errno)
   9197             MHD_DLOG (daemon,
   9198                       _ ("Failed to create a new pool thread because it would " \
   9199                          "have exceeded the system limit on the number of " \
   9200                          "threads or no system resources available.\n"));
   9201           else
   9202 #endif /* EAGAIN */
   9203           MHD_DLOG (daemon,
   9204                     _ ("Failed to create pool thread: %s\n"),
   9205                     MHD_strerror_ (errno));
   9206 #endif
   9207           /* Free memory for this worker; cleanup below handles
   9208            * all previously-created workers. */
   9209           if (MHD_ITC_IS_VALID_ (d->itc))
   9210             MHD_itc_destroy_chk_ (d->itc);
   9211           MHD_mutex_destroy_chk_ (&d->epoll_listen_mutex);
   9212           MHD_mutex_destroy_chk_ (&d->new_connections_mutex);
   9213           MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
   9214           goto thread_failed;
   9215         }
   9216       }
   9217     }
   9218   }
   9219   else
   9220   { /* Daemon without internal threads */
   9221     if (! MHD_mutex_init_ (&daemon->cleanup_connection_mutex))
   9222     {
   9223 #ifdef HAVE_MESSAGES
   9224       MHD_DLOG (daemon,
   9225                 _ ("Failed to initialise internal lists mutex.\n"));
   9226 #endif
   9227       MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9228       goto free_and_fail;
   9229     }
   9230     if (! MHD_mutex_init_ (&daemon->new_connections_mutex))
   9231     {
   9232 #ifdef HAVE_MESSAGES
   9233       MHD_DLOG (daemon,
   9234                 _ ("Failed to initialise mutex.\n"));
   9235 #endif
   9236       MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
   9237       MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9238       goto free_and_fail;
   9239     }
   9240     if (! MHD_mutex_init_ (&daemon->epoll_listen_mutex))
   9241     {
   9242 #ifdef HAVE_MESSAGES
   9243       MHD_DLOG (daemon,
   9244                 _ ("Failed to initialise mutex.\n"));
   9245 #endif
   9246       MHD_mutex_destroy_chk_ (&daemon->new_connections_mutex);
   9247       MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
   9248       MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9249       goto free_and_fail;
   9250     }
   9251   }
   9252 #endif
   9253 #ifdef HTTPS_SUPPORT
   9254   /* API promises to never use the password after initialization,
   9255      so we additionally NULL it here to not deref a dangling pointer. */
   9256   daemon->https_key_password = NULL;
   9257 #endif /* HTTPS_SUPPORT */
   9258 
   9259   return daemon;
   9260 
   9261 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9262 thread_failed:
   9263   /* If no worker threads created, then shut down normally. Calling
   9264      MHD_stop_daemon (as we do below) doesn't work here since it
   9265      assumes a 0-sized thread pool means we had been in the default
   9266      MHD_USE_INTERNAL_POLLING_THREAD mode. */
   9267   if (0 == i)
   9268   {
   9269     MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9270     if (NULL != daemon->worker_pool)
   9271       free (daemon->worker_pool);
   9272     goto free_and_fail;
   9273   }
   9274 
   9275   /* Shutdown worker threads we've already created. Pretend
   9276      as though we had fully initialized our daemon, but
   9277      with a smaller number of threads than had been
   9278      requested. */
   9279   daemon->worker_pool_size = i;
   9280   MHD_stop_daemon (daemon);
   9281   return NULL;
   9282 #endif
   9283 
   9284 free_and_fail:
   9285   /* clean up basic memory state in 'daemon' and return NULL to
   9286      indicate failure */
   9287 #ifdef EPOLL_SUPPORT
   9288 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   9289   if (daemon->upgrade_fd_in_epoll)
   9290   {
   9291     if (0 != epoll_ctl (daemon->epoll_fd,
   9292                         EPOLL_CTL_DEL,
   9293                         daemon->epoll_upgrade_fd,
   9294                         NULL))
   9295       MHD_PANIC (_ ("Failed to remove FD from epoll set.\n"));
   9296     daemon->upgrade_fd_in_epoll = false;
   9297   }
   9298 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   9299   if (-1 != daemon->epoll_fd)
   9300     close (daemon->epoll_fd);
   9301 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   9302   if (-1 != daemon->epoll_upgrade_fd)
   9303     close (daemon->epoll_upgrade_fd);
   9304 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   9305 #endif /* EPOLL_SUPPORT */
   9306 #ifdef DAUTH_SUPPORT
   9307   free (daemon->digest_auth_random_copy);
   9308   free (daemon->nnc);
   9309 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9310   MHD_mutex_destroy_chk_ (&daemon->nnc_lock);
   9311 #endif
   9312 #endif
   9313 #ifdef HTTPS_SUPPORT
   9314   tls_cleanup_failed_start (daemon);
   9315 #endif /* HTTPS_SUPPORT */
   9316   if (MHD_ITC_IS_VALID_ (daemon->itc))
   9317     MHD_itc_destroy_chk_ (daemon->itc);
   9318   if (MHD_INVALID_SOCKET != daemon->listen_fd)
   9319     (void) MHD_socket_close_ (daemon->listen_fd);
   9320   free (daemon);
   9321   return NULL;
   9322 }
   9323 
   9324 
   9325 /**
   9326  * Close all connections for the daemon.
   9327  * Must only be called when MHD_Daemon::shutdown was set to true.
   9328  * @remark To be called only from thread that process
   9329  * daemon's select()/poll()/etc.
   9330  *
   9331  * @param daemon daemon to close down
   9332  */
   9333 static void
   9334 close_all_connections (struct MHD_Daemon *daemon)
   9335 {
   9336   struct MHD_Connection *pos;
   9337   const bool used_thr_p_c = MHD_D_IS_USING_THREAD_PER_CONN_ (daemon);
   9338 #ifdef UPGRADE_SUPPORT
   9339   const bool upg_allowed = (0 != (daemon->options & MHD_ALLOW_UPGRADE));
   9340 #endif /* UPGRADE_SUPPORT */
   9341 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   9342   struct MHD_UpgradeResponseHandle *urh;
   9343   struct MHD_UpgradeResponseHandle *urhn;
   9344   const bool used_tls = (0 != (daemon->options & MHD_USE_TLS));
   9345 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   9346 
   9347 #ifdef MHD_USE_THREADS
   9348   mhd_assert ( (! MHD_D_IS_USING_THREADS_ (daemon)) || \
   9349                MHD_D_IS_USING_THREAD_PER_CONN_ (daemon) || \
   9350                MHD_thread_handle_ID_is_current_thread_ (daemon->tid) );
   9351   mhd_assert (NULL == daemon->worker_pool);
   9352 #endif /* MHD_USE_THREADS */
   9353   mhd_assert (daemon->shutdown);
   9354 
   9355 #ifdef MHD_USE_THREADS
   9356 /* Remove new connections that MHD_add_connection() queued and that were
   9357    * never processed.  This is not limited to daemons with an internal
   9358    * polling thread: internal_add_connection() queues whenever the daemon
   9359    * is thread-safe, which is every daemon that was not started with
   9360    * MHD_USE_NO_THREAD_SAFETY, and new_connections_list_process_()
   9361    * asserts the same condition.  An application driving an external
   9362    * event loop can therefore call MHD_add_connection() and then
   9363    * MHD_stop_daemon() before the next MHD_run(), and this list is what
   9364    * holds the connection at that point. */
   9365   MHD_mutex_lock_chk_ (&daemon->new_connections_mutex);
   9366   while (NULL != (pos = daemon->new_connections_tail))
   9367   {
   9368     mhd_assert (MHD_D_IS_THREAD_SAFE_ (daemon));
   9369     DLL_remove (daemon->new_connections_head,
   9370                 daemon->new_connections_tail,
   9371                 pos);
   9372     new_connection_close_ (daemon, pos);
   9373   }
   9374   MHD_mutex_unlock_chk_ (&daemon->new_connections_mutex);
   9375 #endif /* MHD_USE_THREADS */
   9376 
   9377 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   9378   /* give upgraded HTTPS connections a chance to finish */
   9379   /* 'daemon->urh_head' is not used in thread-per-connection mode. */
   9380   for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
   9381   {
   9382     mhd_assert (! used_thr_p_c);
   9383     urhn = urh->prev;
   9384     /* call generic forwarding function for passing data
   9385        with chance to detect that application is done. */
   9386     process_urh (urh);
   9387     MHD_connection_finish_forward_ (urh->connection);
   9388     urh->clean_ready = true;
   9389     /* Resuming will move connection to cleanup list. */
   9390     MHD_resume_connection (urh->connection);
   9391   }
   9392 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   9393 
   9394   /* Give suspended connections a chance to resume to avoid
   9395      running into the check for there not being any suspended
   9396      connections left in case of a tight race with a recently
   9397      resumed connection. */
   9398   if (0 != (MHD_TEST_ALLOW_SUSPEND_RESUME & daemon->options))
   9399   {
   9400     daemon->resuming = true;   /* Force check for pending resume. */
   9401     resume_suspended_connections (daemon);
   9402   }
   9403   /* first, make sure all threads are aware of shutdown; need to
   9404      traverse DLLs in peace... */
   9405 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9406   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   9407 #endif
   9408 #ifdef UPGRADE_SUPPORT
   9409   if (upg_allowed)
   9410   {
   9411     struct MHD_Connection *susp;
   9412 
   9413     susp = daemon->suspended_connections_tail;
   9414     while (NULL != susp)
   9415     {
   9416       if (NULL == susp->urh)     /* "Upgraded" connection? */
   9417         MHD_PANIC (_ ("MHD_stop_daemon() called while we have " \
   9418                       "suspended connections.\n"));
   9419 #ifdef HTTPS_SUPPORT
   9420       else if (used_tls &&
   9421                used_thr_p_c &&
   9422                (! susp->urh->clean_ready) )
   9423         shutdown (susp->urh->app.socket,
   9424                   SHUT_RDWR);     /* Wake thread by shutdown of app socket. */
   9425 #endif /* HTTPS_SUPPORT */
   9426       else
   9427       {
   9428 #ifdef HAVE_MESSAGES
   9429         if (! susp->urh->was_closed)
   9430           MHD_DLOG (daemon,
   9431                     _ ("Initiated daemon shutdown while \"upgraded\" " \
   9432                        "connection was not closed.\n"));
   9433 #endif
   9434         susp->urh->was_closed = true;
   9435         /* If thread-per-connection is used, connection's thread
   9436          * may still processing "upgrade" (exiting). */
   9437         if (! used_thr_p_c)
   9438           MHD_connection_finish_forward_ (susp);
   9439         /* Do not use MHD_resume_connection() as mutex is
   9440          * already locked. */
   9441         susp->resuming = true;
   9442         daemon->resuming = true;
   9443       }
   9444       susp = susp->prev;
   9445     }
   9446   }
   9447   else /* This 'else' is combined with next 'if' */
   9448 #endif /* UPGRADE_SUPPORT */
   9449   if (NULL != daemon->suspended_connections_head)
   9450     MHD_PANIC (_ ("MHD_stop_daemon() called while we have " \
   9451                   "suspended connections.\n"));
   9452 #if defined(UPGRADE_SUPPORT) && defined(HTTPS_SUPPORT)
   9453 #ifdef MHD_USE_THREADS
   9454   if (upg_allowed && used_tls && used_thr_p_c)
   9455   {
   9456     /* "Upgraded" threads may be running in parallel. Connection will not be
   9457      * moved to the "cleanup list" until connection's thread finishes.
   9458      * We must ensure that all "upgraded" connections are finished otherwise
   9459      * connection may stay in "suspended" list and will not be cleaned. */
   9460     for (pos = daemon->suspended_connections_tail; NULL != pos; pos = pos->prev)
   9461     {
   9462       /* Any connection found here is "upgraded" connection, normal suspended
   9463        * connections are already removed from this list. */
   9464       mhd_assert (NULL != pos->urh);
   9465       if (! pos->thread_joined)
   9466       {
   9467         /* While "cleanup" list is not manipulated by "upgraded"
   9468          * connection, "cleanup" mutex is required for call of
   9469          * MHD_resume_connection() during finishing of "upgraded"
   9470          * thread. */
   9471         MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   9472         if (! MHD_thread_handle_ID_join_thread_ (pos->tid))
   9473           MHD_PANIC (_ ("Failed to join a thread.\n"));
   9474         pos->thread_joined = true;
   9475         MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   9476       }
   9477     }
   9478   }
   9479 #endif /* MHD_USE_THREADS */
   9480 #endif
   9481   for (pos = daemon->connections_tail; NULL != pos; pos = pos->prev)
   9482   {
   9483     shutdown (pos->socket_fd,
   9484               SHUT_RDWR);
   9485 #ifdef MHD_WINSOCK_SOCKETS
   9486     if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon) &&
   9487         (MHD_ITC_IS_VALID_ (daemon->itc)) &&
   9488         (! MHD_itc_activate_ (daemon->itc, "e")) )
   9489       MHD_PANIC (_ ("Failed to signal shutdown via inter-thread " \
   9490                     "communication channel.\n"));
   9491 #endif
   9492   }
   9493 
   9494 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9495   /* now, collect per-connection threads */
   9496   if (used_thr_p_c)
   9497   {
   9498     pos = daemon->connections_tail;
   9499     while (NULL != pos)
   9500     {
   9501       if (! pos->thread_joined)
   9502       {
   9503         MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   9504         if (! MHD_thread_handle_ID_join_thread_ (pos->tid))
   9505           MHD_PANIC (_ ("Failed to join a thread.\n"));
   9506         MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   9507         pos->thread_joined = true;
   9508         /* The thread may have concurrently modified the DLL,
   9509            need to restart from the beginning */
   9510         pos = daemon->connections_tail;
   9511         continue;
   9512       }
   9513       pos = pos->prev;
   9514     }
   9515   }
   9516   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   9517 #endif
   9518 
   9519 #ifdef UPGRADE_SUPPORT
   9520   /* Finished threads with "upgraded" connections need to be moved
   9521    * to cleanup list by resume_suspended_connections(). */
   9522   /* "Upgraded" connections that were not closed explicitly by
   9523    * application should be moved to cleanup list too. */
   9524   if (upg_allowed)
   9525   {
   9526     daemon->resuming = true;   /* Force check for pending resume. */
   9527     resume_suspended_connections (daemon);
   9528   }
   9529 #endif /* UPGRADE_SUPPORT */
   9530 
   9531   mhd_assert (NULL == daemon->suspended_connections_head);
   9532   /* now that we're alone, move everyone to cleanup */
   9533   while (NULL != (pos = daemon->connections_tail))
   9534   {
   9535 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9536     if (MHD_D_IS_USING_THREAD_PER_CONN_ (daemon) &&
   9537         (! pos->thread_joined) )
   9538       MHD_PANIC (_ ("Failed to join a thread.\n"));
   9539 #endif
   9540     close_connection (pos);
   9541   }
   9542   MHD_cleanup_connections (daemon);
   9543 }
   9544 
   9545 
   9546 /**
   9547  * Shutdown an HTTP daemon.
   9548  *
   9549  * @param daemon daemon to stop
   9550  * @ingroup event
   9551  */
   9552 _MHD_EXTERN void
   9553 MHD_stop_daemon (struct MHD_Daemon *daemon)
   9554 {
   9555   MHD_socket fd;
   9556 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9557   unsigned int i;
   9558 #endif
   9559 
   9560   if (NULL == daemon)
   9561     return;
   9562   if ( (daemon->shutdown) && (NULL == daemon->master) )
   9563     MHD_PANIC (_ ("MHD_stop_daemon() was called twice."));
   9564 
   9565   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   9566               (NULL != daemon->worker_pool) || \
   9567               (MHD_thread_handle_ID_is_valid_handle_ (daemon->tid)));
   9568   mhd_assert (((0 != (daemon->options & MHD_USE_SELECT_INTERNALLY)) &&
   9569                (NULL == daemon->worker_pool)) || \
   9570               (! MHD_thread_handle_ID_is_valid_handle_ (daemon->tid)));
   9571 
   9572   /* Slave daemons must be stopped by master daemon. */
   9573   mhd_assert ( (NULL == daemon->master) || (daemon->shutdown) );
   9574 
   9575   daemon->shutdown = true;
   9576   if (daemon->was_quiesced)
   9577     fd = MHD_INVALID_SOCKET; /* Do not use FD if daemon was quiesced */
   9578   else
   9579     fd = daemon->listen_fd;
   9580 
   9581 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9582   if (NULL != daemon->worker_pool)
   9583   {   /* Master daemon with worker pool. */
   9584     mhd_assert (1 < daemon->worker_pool_size);
   9585     mhd_assert (MHD_D_IS_USING_THREADS_ (daemon));
   9586 
   9587     /* Let workers shutdown in parallel. */
   9588     for (i = 0; i < daemon->worker_pool_size; ++i)
   9589     {
   9590       daemon->worker_pool[i].shutdown = true;
   9591       if (MHD_ITC_IS_VALID_ (daemon->worker_pool[i].itc))
   9592       {
   9593         if (! MHD_itc_activate_ (daemon->worker_pool[i].itc,
   9594                                  "e"))
   9595           MHD_PANIC (_ ("Failed to signal shutdown via inter-thread " \
   9596                         "communication channel.\n"));
   9597       }
   9598       else
   9599         mhd_assert (MHD_INVALID_SOCKET != fd);
   9600     }
   9601 #ifdef HAVE_LISTEN_SHUTDOWN
   9602     if (MHD_INVALID_SOCKET != fd)
   9603     {
   9604       (void) shutdown (fd,
   9605                        SHUT_RDWR);
   9606     }
   9607 #endif /* HAVE_LISTEN_SHUTDOWN */
   9608     for (i = 0; i < daemon->worker_pool_size; ++i)
   9609     {
   9610       MHD_stop_daemon (&daemon->worker_pool[i]);
   9611     }
   9612     free (daemon->worker_pool);
   9613     mhd_assert (MHD_ITC_IS_INVALID_ (daemon->itc));
   9614 #ifdef EPOLL_SUPPORT
   9615     mhd_assert (-1 == daemon->epoll_fd);
   9616 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   9617     mhd_assert (-1 == daemon->epoll_upgrade_fd);
   9618 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   9619 #endif /* EPOLL_SUPPORT */
   9620   }
   9621   else
   9622 #endif
   9623   {   /* Worker daemon or single daemon. */
   9624 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9625     if (MHD_D_IS_USING_THREADS_ (daemon))
   9626     {     /* Worker daemon or single daemon with internal thread(s). */
   9627       mhd_assert (0 == daemon->worker_pool_size);
   9628       /* Separate thread(s) is used for polling sockets. */
   9629       if (MHD_ITC_IS_VALID_ (daemon->itc))
   9630       {
   9631         if (! MHD_itc_activate_ (daemon->itc,
   9632                                  "e"))
   9633           MHD_PANIC (_ ("Failed to signal shutdown via inter-thread " \
   9634                         "communication channel.\n"));
   9635       }
   9636       else
   9637       {
   9638 #ifdef HAVE_LISTEN_SHUTDOWN
   9639         if (MHD_INVALID_SOCKET != fd)
   9640         {
   9641           if (NULL == daemon->master)
   9642             (void) shutdown (fd,
   9643                              SHUT_RDWR);
   9644         }
   9645         else
   9646 #endif /* HAVE_LISTEN_SHUTDOWN */
   9647         mhd_assert (false); /* Should never happen */
   9648       }
   9649 
   9650       if (! MHD_thread_handle_ID_join_thread_ (daemon->tid))
   9651       {
   9652         MHD_PANIC (_ ("Failed to join a thread.\n"));
   9653       }
   9654       /* close_all_connections() was called in daemon thread. */
   9655     }
   9656     else
   9657 #endif
   9658     {
   9659       /* No internal threads are used for polling sockets. */
   9660       close_all_connections (daemon);
   9661     }
   9662     mhd_assert (NULL == daemon->connections_head);
   9663     mhd_assert (NULL == daemon->cleanup_head);
   9664     mhd_assert (NULL == daemon->suspended_connections_head);
   9665     mhd_assert (NULL == daemon->new_connections_head);
   9666 #if defined(UPGRADE_SUPPORT) && defined(HTTPS_SUPPORT)
   9667     mhd_assert (NULL == daemon->urh_head);
   9668 #endif /* UPGRADE_SUPPORT && HTTPS_SUPPORT */
   9669 
   9670     if (MHD_ITC_IS_VALID_ (daemon->itc))
   9671       MHD_itc_destroy_chk_ (daemon->itc);
   9672 
   9673 #ifdef EPOLL_SUPPORT
   9674     if (MHD_D_IS_USING_EPOLL_ (daemon) &&
   9675         (-1 != daemon->epoll_fd) )
   9676       MHD_socket_close_chk_ (daemon->epoll_fd);
   9677 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   9678     if (MHD_D_IS_USING_EPOLL_ (daemon) &&
   9679         (-1 != daemon->epoll_upgrade_fd) )
   9680       MHD_socket_close_chk_ (daemon->epoll_upgrade_fd);
   9681 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   9682 #endif /* EPOLL_SUPPORT */
   9683 
   9684 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9685     MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
   9686     MHD_mutex_destroy_chk_ (&daemon->epoll_listen_mutex);
   9687     MHD_mutex_destroy_chk_ (&daemon->new_connections_mutex);
   9688 #endif
   9689   }
   9690 
   9691   if (NULL == daemon->master)
   9692   {   /* Cleanup that should be done only one time in master/single daemon.
   9693        * Do not perform this cleanup in worker daemons. */
   9694 
   9695     if (MHD_INVALID_SOCKET != fd)
   9696       MHD_socket_close_chk_ (fd);
   9697 
   9698     /* TLS clean up */
   9699 #ifdef HTTPS_SUPPORT
   9700     if (daemon->have_dhparams)
   9701     {
   9702       gnutls_dh_params_deinit (daemon->https_mem_dhparams);
   9703       daemon->have_dhparams = false;
   9704     }
   9705     if (0 != (daemon->options & MHD_USE_TLS))
   9706     {
   9707       gnutls_priority_deinit (daemon->priority_cache);
   9708       if (daemon->x509_cred)
   9709         gnutls_certificate_free_credentials (daemon->x509_cred);
   9710       if (daemon->psk_cred)
   9711         gnutls_psk_free_server_credentials (daemon->psk_cred);
   9712     }
   9713 #endif /* HTTPS_SUPPORT */
   9714 
   9715 #ifdef DAUTH_SUPPORT
   9716     free (daemon->digest_auth_random_copy);
   9717     free (daemon->nnc);
   9718 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9719     MHD_mutex_destroy_chk_ (&daemon->nnc_lock);
   9720 #endif
   9721 #endif
   9722 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9723     MHD_mutex_destroy_chk_ (&daemon->per_ip_connection_mutex);
   9724 #endif
   9725     free (daemon);
   9726   }
   9727 }
   9728 
   9729 
   9730 /**
   9731  * Obtain information about the given daemon.
   9732  * The returned pointer is invalidated with the next call of this function or
   9733  * when the daemon is stopped.
   9734  *
   9735  * @param daemon what daemon to get information about
   9736  * @param info_type what information is desired?
   9737  * @param ... depends on @a info_type
   9738  * @return NULL if this information is not available
   9739  *         (or if the @a info_type is unknown)
   9740  * @ingroup specialized
   9741  */
   9742 _MHD_EXTERN const union MHD_DaemonInfo *
   9743 MHD_get_daemon_info (struct MHD_Daemon *daemon,
   9744                      enum MHD_DaemonInfoType info_type,
   9745                      ...)
   9746 {
   9747   if (NULL == daemon)
   9748     return NULL;
   9749 
   9750   mhd_assert ((0 == (daemon->options & MHD_USE_SELECT_INTERNALLY)) || \
   9751               (NULL != daemon->worker_pool) || \
   9752               (MHD_thread_handle_ID_is_valid_handle_ (daemon->tid)));
   9753   mhd_assert (((0 != (daemon->options & MHD_USE_SELECT_INTERNALLY)) &&
   9754                (NULL == daemon->worker_pool)) || \
   9755               (! MHD_thread_handle_ID_is_valid_handle_ (daemon->tid)));
   9756 
   9757   switch (info_type)
   9758   {
   9759   case MHD_DAEMON_INFO_KEY_SIZE:
   9760     return NULL;   /* no longer supported */
   9761   case MHD_DAEMON_INFO_MAC_KEY_SIZE:
   9762     return NULL;   /* no longer supported */
   9763   case MHD_DAEMON_INFO_LISTEN_FD:
   9764     daemon->daemon_info_dummy_listen_fd.listen_fd = daemon->listen_fd;
   9765     return &daemon->daemon_info_dummy_listen_fd;
   9766   case MHD_DAEMON_INFO_EPOLL_FD:
   9767 #ifdef EPOLL_SUPPORT
   9768     daemon->daemon_info_dummy_epoll_fd.epoll_fd = daemon->epoll_fd;
   9769     return &daemon->daemon_info_dummy_epoll_fd;
   9770 #else  /* ! EPOLL_SUPPORT */
   9771     return NULL;
   9772 #endif /* ! EPOLL_SUPPORT */
   9773   case MHD_DAEMON_INFO_CURRENT_CONNECTIONS:
   9774     if (! MHD_D_IS_THREAD_SAFE_ (daemon))
   9775       MHD_cleanup_connections (daemon);
   9776 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
   9777     else if (daemon->worker_pool)
   9778     {
   9779       unsigned int i;
   9780       /* Collect the connection information stored in the workers. */
   9781       daemon->connections = 0;
   9782       for (i = 0; i < daemon->worker_pool_size; i++)
   9783       {
   9784         /* FIXME: next line is thread-safe only if read is atomic. */
   9785         daemon->connections += daemon->worker_pool[i].connections;
   9786       }
   9787     }
   9788 #endif
   9789     daemon->daemon_info_dummy_num_connections.num_connections
   9790       = daemon->connections;
   9791     return &daemon->daemon_info_dummy_num_connections;
   9792   case MHD_DAEMON_INFO_FLAGS:
   9793     daemon->daemon_info_dummy_flags.flags = daemon->options;
   9794     return &daemon->daemon_info_dummy_flags;
   9795   case MHD_DAEMON_INFO_BIND_PORT:
   9796     daemon->daemon_info_dummy_port.port = daemon->port;
   9797     return &daemon->daemon_info_dummy_port;
   9798   default:
   9799     return NULL;
   9800   }
   9801 }
   9802 
   9803 
   9804 /**
   9805  * Obtain the version of this library
   9806  *
   9807  * @return static version string, e.g. "0.9.9"
   9808  * @ingroup specialized
   9809  */
   9810 _MHD_EXTERN const char *
   9811 MHD_get_version (void)
   9812 {
   9813 #ifdef PACKAGE_VERSION
   9814   return PACKAGE_VERSION;
   9815 #else  /* !PACKAGE_VERSION */
   9816   static char ver[12] = "\0\0\0\0\0\0\0\0\0\0\0";
   9817   if (0 == ver[0])
   9818   {
   9819     int res = MHD_snprintf_ (ver,
   9820                              sizeof(ver),
   9821                              "%x.%x.%x",
   9822                              (int) (((uint32_t) MHD_VERSION >> 24) & 0xFF),
   9823                              (int) (((uint32_t) MHD_VERSION >> 16) & 0xFF),
   9824                              (int) (((uint32_t) MHD_VERSION >> 8) & 0xFF));
   9825     if ((0 >= res) || (sizeof(ver) <= res))
   9826       return "0.0.0"; /* Can't return real version */
   9827   }
   9828   return ver;
   9829 #endif /* !PACKAGE_VERSION */
   9830 }
   9831 
   9832 
   9833 /**
   9834  * Obtain the version of this library as a binary value.
   9835  *
   9836  * @return version binary value, e.g. "0x00090900" (#MHD_VERSION of
   9837  *         compiled MHD binary)
   9838  * @note Available since #MHD_VERSION 0x00097601
   9839  * @ingroup specialized
   9840  */
   9841 _MHD_EXTERN uint32_t
   9842 MHD_get_version_bin (void)
   9843 {
   9844   return (uint32_t) MHD_VERSION;
   9845 }
   9846 
   9847 
   9848 /**
   9849  * Get information about supported MHD features.
   9850  * Indicate that MHD was compiled with or without support for
   9851  * particular feature. Some features require additional support
   9852  * by kernel. Kernel support is not checked by this function.
   9853  *
   9854  * @param feature type of requested information
   9855  * @return #MHD_YES if feature is supported by MHD, #MHD_NO if
   9856  * feature is not supported or feature is unknown.
   9857  * @ingroup specialized
   9858  */
   9859 _MHD_EXTERN enum MHD_Result
   9860 MHD_is_feature_supported (enum MHD_FEATURE feature)
   9861 {
   9862   switch (feature)
   9863   {
   9864   case MHD_FEATURE_MESSAGES:
   9865 #ifdef HAVE_MESSAGES
   9866     return MHD_YES;
   9867 #else
   9868     return MHD_NO;
   9869 #endif
   9870   case MHD_FEATURE_TLS:
   9871 #ifdef HTTPS_SUPPORT
   9872     return MHD_YES;
   9873 #else  /* ! HTTPS_SUPPORT */
   9874     return MHD_NO;
   9875 #endif  /* ! HTTPS_SUPPORT */
   9876   case MHD_FEATURE_HTTPS_CERT_CALLBACK:
   9877 #if defined(HTTPS_SUPPORT) && GNUTLS_VERSION_MAJOR >= 3
   9878     return MHD_YES;
   9879 #else  /* !HTTPS_SUPPORT || GNUTLS_VERSION_MAJOR < 3 */
   9880     return MHD_NO;
   9881 #endif /* !HTTPS_SUPPORT || GNUTLS_VERSION_MAJOR < 3 */
   9882   case MHD_FEATURE_HTTPS_CERT_CALLBACK2:
   9883 #if defined(HTTPS_SUPPORT) && GNUTLS_VERSION_NUMBER >= 0x030603
   9884     return MHD_YES;
   9885 #else  /* !HTTPS_SUPPORT || GNUTLS_VERSION_NUMBER < 0x030603 */
   9886     return MHD_NO;
   9887 #endif /* !HTTPS_SUPPORT || GNUTLS_VERSION_NUMBER < 0x030603 */
   9888   case MHD_FEATURE_IPv6:
   9889 #ifdef HAVE_INET6
   9890     return MHD_YES;
   9891 #else
   9892     return MHD_NO;
   9893 #endif
   9894   case MHD_FEATURE_IPv6_ONLY:
   9895 #if defined(IPPROTO_IPV6) && defined(IPV6_V6ONLY)
   9896     return MHD_YES;
   9897 #else
   9898     return MHD_NO;
   9899 #endif
   9900   case MHD_FEATURE_POLL:
   9901 #ifdef HAVE_POLL
   9902     return MHD_YES;
   9903 #else
   9904     return MHD_NO;
   9905 #endif
   9906   case MHD_FEATURE_EPOLL:
   9907 #ifdef EPOLL_SUPPORT
   9908     return MHD_YES;
   9909 #else
   9910     return MHD_NO;
   9911 #endif
   9912   case MHD_FEATURE_SHUTDOWN_LISTEN_SOCKET:
   9913 #ifdef HAVE_LISTEN_SHUTDOWN
   9914     return MHD_YES;
   9915 #else
   9916     return MHD_NO;
   9917 #endif
   9918   case MHD_FEATURE_SOCKETPAIR:
   9919 #ifdef _MHD_ITC_SOCKETPAIR
   9920     return MHD_YES;
   9921 #else
   9922     return MHD_NO;
   9923 #endif
   9924   case MHD_FEATURE_TCP_FASTOPEN:
   9925 #ifdef TCP_FASTOPEN
   9926     return MHD_YES;
   9927 #else
   9928     return MHD_NO;
   9929 #endif
   9930   case MHD_FEATURE_BASIC_AUTH:
   9931 #ifdef BAUTH_SUPPORT
   9932     return MHD_YES;
   9933 #else
   9934     return MHD_NO;
   9935 #endif
   9936   case MHD_FEATURE_DIGEST_AUTH:
   9937 #ifdef DAUTH_SUPPORT
   9938     return MHD_YES;
   9939 #else
   9940     return MHD_NO;
   9941 #endif
   9942   case MHD_FEATURE_POSTPROCESSOR:
   9943 #ifdef HAVE_POSTPROCESSOR
   9944     return MHD_YES;
   9945 #else
   9946     return MHD_NO;
   9947 #endif
   9948   case MHD_FEATURE_HTTPS_KEY_PASSWORD:
   9949 #if defined(HTTPS_SUPPORT) && GNUTLS_VERSION_NUMBER >= 0x030111
   9950     return MHD_YES;
   9951 #else  /* !HTTPS_SUPPORT || GNUTLS_VERSION_NUMBER < 0x030111 */
   9952     return MHD_NO;
   9953 #endif /* !HTTPS_SUPPORT || GNUTLS_VERSION_NUMBER < 0x030111 */
   9954   case MHD_FEATURE_LARGE_FILE:
   9955 #if defined(HAVE_PREAD64) || defined(_WIN32)
   9956     return MHD_YES;
   9957 #elif defined(HAVE_PREAD)
   9958     return (sizeof(uint64_t) > sizeof(off_t)) ? MHD_NO : MHD_YES;
   9959 #elif defined(HAVE_LSEEK64)
   9960     return MHD_YES;
   9961 #else
   9962     return (sizeof(uint64_t) > sizeof(off_t)) ? MHD_NO : MHD_YES;
   9963 #endif
   9964   case MHD_FEATURE_THREAD_NAMES:
   9965 #if defined(MHD_USE_THREAD_NAME_)
   9966     return MHD_YES;
   9967 #else
   9968     return MHD_NO;
   9969 #endif
   9970   case MHD_FEATURE_UPGRADE:
   9971 #if defined(UPGRADE_SUPPORT)
   9972     return MHD_YES;
   9973 #else
   9974     return MHD_NO;
   9975 #endif
   9976   case MHD_FEATURE_RESPONSES_SHARED_FD:
   9977 #if defined(HAVE_PREAD64) || defined(HAVE_PREAD) || defined(_WIN32)
   9978     return MHD_YES;
   9979 #else
   9980     return MHD_NO;
   9981 #endif
   9982   case MHD_FEATURE_AUTODETECT_BIND_PORT:
   9983 #ifdef MHD_USE_GETSOCKNAME
   9984     return MHD_YES;
   9985 #else
   9986     return MHD_NO;
   9987 #endif
   9988   case MHD_FEATURE_AUTOSUPPRESS_SIGPIPE:
   9989 #if defined(MHD_SEND_SPIPE_SUPPRESS_POSSIBLE) || \
   9990     ! defined(MHD_SEND_SPIPE_SUPPRESS_NEEDED)
   9991     return MHD_YES;
   9992 #else
   9993     return MHD_NO;
   9994 #endif
   9995   case MHD_FEATURE_SENDFILE:
   9996 #ifdef _MHD_HAVE_SENDFILE
   9997     return MHD_YES;
   9998 #else
   9999     return MHD_NO;
  10000 #endif
  10001   case MHD_FEATURE_THREADS:
  10002 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  10003     return MHD_YES;
  10004 #else
  10005     return MHD_NO;
  10006 #endif
  10007   case MHD_FEATURE_COOKIE_PARSING:
  10008 #if defined(COOKIE_SUPPORT)
  10009     return MHD_YES;
  10010 #else
  10011     return MHD_NO;
  10012 #endif
  10013   case MHD_FEATURE_DIGEST_AUTH_RFC2069:
  10014 #ifdef DAUTH_SUPPORT
  10015     return MHD_YES;
  10016 #else
  10017     return MHD_NO;
  10018 #endif
  10019   case MHD_FEATURE_DIGEST_AUTH_MD5:
  10020 #if defined(DAUTH_SUPPORT) && defined(MHD_MD5_SUPPORT)
  10021     return MHD_YES;
  10022 #else
  10023     return MHD_NO;
  10024 #endif
  10025   case MHD_FEATURE_DIGEST_AUTH_SHA256:
  10026 #if defined(DAUTH_SUPPORT) && defined(MHD_SHA256_SUPPORT)
  10027     return MHD_YES;
  10028 #else
  10029     return MHD_NO;
  10030 #endif
  10031   case MHD_FEATURE_DIGEST_AUTH_SHA512_256:
  10032 #if defined(DAUTH_SUPPORT) && defined(MHD_SHA512_256_SUPPORT)
  10033     return MHD_YES;
  10034 #else
  10035     return MHD_NO;
  10036 #endif
  10037   case MHD_FEATURE_DIGEST_AUTH_AUTH_INT:
  10038 #ifdef DAUTH_SUPPORT
  10039     return MHD_NO;
  10040 #else
  10041     return MHD_NO;
  10042 #endif
  10043   case MHD_FEATURE_DIGEST_AUTH_ALGO_SESSION:
  10044 #ifdef DAUTH_SUPPORT
  10045     return MHD_NO;
  10046 #else
  10047     return MHD_NO;
  10048 #endif
  10049   case MHD_FEATURE_DIGEST_AUTH_USERHASH:
  10050 #ifdef DAUTH_SUPPORT
  10051     return MHD_YES;
  10052 #else
  10053     return MHD_NO;
  10054 #endif
  10055   case MHD_FEATURE_EXTERN_HASH:
  10056 #if defined(MHD_MD5_TLSLIB) || defined(MHD_SHA256_TLSLIB)
  10057     return MHD_YES;
  10058 #else
  10059     return MHD_NO;
  10060 #endif
  10061   case MHD_FEATURE_DEBUG_BUILD:
  10062 #ifdef _DEBUG
  10063     return MHD_YES;
  10064 #else
  10065     return MHD_NO;
  10066 #endif
  10067   case MHD_FEATURE_FLEXIBLE_FD_SETSIZE:
  10068 #ifdef HAS_FD_SETSIZE_OVERRIDABLE
  10069     return MHD_YES;
  10070 #else  /* ! HAS_FD_SETSIZE_OVERRIDABLE */
  10071     return MHD_NO;
  10072 #endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */
  10073 
  10074   default:
  10075     break;
  10076   }
  10077   return MHD_NO;
  10078 }
  10079 
  10080 
  10081 #ifdef MHD_HTTPS_REQUIRE_GCRYPT
  10082 #if defined(HTTPS_SUPPORT) && GCRYPT_VERSION_NUMBER < 0x010600
  10083 #if defined(MHD_USE_POSIX_THREADS)
  10084 GCRY_THREAD_OPTION_PTHREAD_IMPL;
  10085 #elif defined(MHD_W32_MUTEX_)
  10086 
  10087 static int
  10088 gcry_w32_mutex_init (void **ppmtx)
  10089 {
  10090   *ppmtx = malloc (sizeof (MHD_mutex_));
  10091 
  10092   if (NULL == *ppmtx)
  10093     return ENOMEM;
  10094   if (! MHD_mutex_init_ ((MHD_mutex_ *) *ppmtx))
  10095   {
  10096     free (*ppmtx);
  10097     *ppmtx = NULL;
  10098     return EPERM;
  10099   }
  10100 
  10101   return 0;
  10102 }
  10103 
  10104 
  10105 static int
  10106 gcry_w32_mutex_destroy (void **ppmtx)
  10107 {
  10108   int res = (MHD_mutex_destroy_ ((MHD_mutex_ *) *ppmtx)) ? 0 : EINVAL;
  10109   free (*ppmtx);
  10110   return res;
  10111 }
  10112 
  10113 
  10114 static int
  10115 gcry_w32_mutex_lock (void **ppmtx)
  10116 {
  10117   return MHD_mutex_lock_ ((MHD_mutex_ *) *ppmtx) ? 0 : EINVAL;
  10118 }
  10119 
  10120 
  10121 static int
  10122 gcry_w32_mutex_unlock (void **ppmtx)
  10123 {
  10124   return MHD_mutex_unlock_ ((MHD_mutex_ *) *ppmtx) ? 0 : EINVAL;
  10125 }
  10126 
  10127 
  10128 static struct gcry_thread_cbs gcry_threads_w32 = {
  10129   (GCRY_THREAD_OPTION_USER | (GCRY_THREAD_OPTION_VERSION << 8)),
  10130   NULL, gcry_w32_mutex_init, gcry_w32_mutex_destroy,
  10131   gcry_w32_mutex_lock, gcry_w32_mutex_unlock,
  10132   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  10133 };
  10134 
  10135 #endif /* defined(MHD_W32_MUTEX_) */
  10136 #endif /* HTTPS_SUPPORT && GCRYPT_VERSION_NUMBER < 0x010600 */
  10137 #endif /* MHD_HTTPS_REQUIRE_GCRYPT */
  10138 
  10139 /**
  10140  * Initialize do setup work.
  10141  */
  10142 void
  10143 MHD_init (void)
  10144 {
  10145 #if defined(MHD_WINSOCK_SOCKETS)
  10146   WSADATA wsd;
  10147 #endif /* MHD_WINSOCK_SOCKETS */
  10148 
  10149   MHD_set_panic_func (NULL, NULL);
  10150 
  10151 #if defined(MHD_WINSOCK_SOCKETS)
  10152   if (0 != WSAStartup (MAKEWORD (2, 2), &wsd))
  10153     MHD_PANIC (_ ("Failed to initialize winsock.\n"));
  10154   if ((2 != LOBYTE (wsd.wVersion)) && (2 != HIBYTE (wsd.wVersion)))
  10155     MHD_PANIC (_ ("Winsock version 2.2 is not available.\n"));
  10156 #endif /* MHD_WINSOCK_SOCKETS */
  10157 #ifdef HTTPS_SUPPORT
  10158 #ifdef MHD_HTTPS_REQUIRE_GCRYPT
  10159 #if GCRYPT_VERSION_NUMBER < 0x010600
  10160 #if GNUTLS_VERSION_NUMBER <= 0x020b00
  10161 #if defined(MHD_USE_POSIX_THREADS)
  10162   if (0 != gcry_control (GCRYCTL_SET_THREAD_CBS,
  10163                          &gcry_threads_pthread))
  10164     MHD_PANIC (_ ("Failed to initialise multithreading in libgcrypt.\n"));
  10165 #elif defined(MHD_W32_MUTEX_)
  10166   if (0 != gcry_control (GCRYCTL_SET_THREAD_CBS,
  10167                          &gcry_threads_w32))
  10168     MHD_PANIC (_ ("Failed to initialise multithreading in libgcrypt.\n"));
  10169 #endif /* defined(MHD_W32_MUTEX_) */
  10170 #endif /* GNUTLS_VERSION_NUMBER <= 0x020b00 */
  10171   gcry_check_version (NULL);
  10172 #else
  10173   if (NULL == gcry_check_version ("1.6.0"))
  10174     MHD_PANIC (_ ("libgcrypt is too old. MHD was compiled for " \
  10175                   "libgcrypt 1.6.0 or newer.\n"));
  10176 #endif
  10177 #endif /* MHD_HTTPS_REQUIRE_GCRYPT */
  10178   gnutls_global_init ();
  10179 #endif /* HTTPS_SUPPORT */
  10180   MHD_monotonic_sec_counter_init ();
  10181   MHD_send_init_static_vars_ ();
  10182   MHD_init_mem_pools_ ();
  10183   /* Check whether sizes were correctly detected by configure */
  10184 #ifdef _DEBUG
  10185   if (1)
  10186   {
  10187     struct timeval tv;
  10188     mhd_assert (sizeof(tv.tv_sec) == SIZEOF_STRUCT_TIMEVAL_TV_SEC);
  10189   }
  10190 #endif /* _DEBUG */
  10191   mhd_assert (sizeof(uint64_t) == SIZEOF_UINT64_T);
  10192 }
  10193 
  10194 
  10195 void
  10196 MHD_fini (void)
  10197 {
  10198 #ifdef HTTPS_SUPPORT
  10199   gnutls_global_deinit ();
  10200 #endif /* HTTPS_SUPPORT */
  10201 #if defined(MHD_WINSOCK_SOCKETS)
  10202   WSACleanup ();
  10203 #endif /* MHD_WINSOCK_SOCKETS */
  10204   MHD_monotonic_sec_counter_finish ();
  10205 }
  10206 
  10207 
  10208 #ifdef _AUTOINIT_FUNCS_ARE_SUPPORTED
  10209 _SET_INIT_AND_DEINIT_FUNCS (MHD_init, MHD_fini);
  10210 #endif /* _AUTOINIT_FUNCS_ARE_SUPPORTED */
  10211 
  10212 /* end of daemon.c */