civetweb.c

Go to the documentation of this file.

/* Copyright (c) 2013-2021 the Civetweb developers
 * Copyright (c) 2004-2013 Sergey Lyubka
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#if defined(__GNUC__) || defined(__MINGW32__)
#define GCC_VERSION                                                            \
   (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#if GCC_VERSION >= 40500
/* gcc diagnostic pragmas available */
#define GCC_DIAGNOSTIC
#endif
#endif
 
#if defined(GCC_DIAGNOSTIC)
/* Disable unused macros warnings - not all defines are required
 * for all systems and all compilers. */
#pragma GCC diagnostic ignored "-Wunused-macros"
/* A padding warning is just plain useless */
#pragma GCC diagnostic ignored "-Wpadded"
#endif
 
#if defined(__clang__) /* GCC does not (yet) support this pragma */
/* We must set some flags for the headers we include. These flags
 * are reserved ids according to C99, so we need to disable a
 * warning for that. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreserved-id-macro"
#endif
 
#if defined(_WIN32)
#if !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS /* Disable deprecation warning in VS2005 */
#endif
#if !defined(_WIN32_WINNT) /* defined for tdm-gcc so we can use getnameinfo */
#define _WIN32_WINNT 0x0502
#endif
#else
#if !defined(_GNU_SOURCE)
#define _GNU_SOURCE /* for setgroups(), pthread_setname_np() */
#endif
#if defined(__linux__) && !defined(_XOPEN_SOURCE)
#define _XOPEN_SOURCE 600 /* For flockfile() on Linux */
#endif
#if defined(__LSB_VERSION__) || defined(__sun)
#define NEED_TIMEGM
#define NO_THREAD_NAME
#endif
#if !defined(_LARGEFILE_SOURCE)
#define _LARGEFILE_SOURCE /* For fseeko(), ftello() */
#endif
#if !defined(_FILE_OFFSET_BITS)
#define _FILE_OFFSET_BITS 64 /* Use 64-bit file offsets by default */
#endif
#if !defined(__STDC_FORMAT_MACROS)
#define __STDC_FORMAT_MACROS /* <inttypes.h> wants this for C++ */
#endif
#if !defined(__STDC_LIMIT_MACROS)
#define __STDC_LIMIT_MACROS /* C++ wants that for INT64_MAX */
#endif
#if !defined(_DARWIN_UNLIMITED_SELECT)
#define _DARWIN_UNLIMITED_SELECT
#endif
#if defined(__sun)
#define __EXTENSIONS__  /* to expose flockfile and friends in stdio.h */
#define __inline inline /* not recognized on older compiler versions */
#endif
#endif
 
#if defined(__clang__)
/* Enable reserved-id-macro warning again. */
#pragma GCC diagnostic pop
#endif
 
 
#if defined(USE_LUA)
#define USE_TIMERS
#endif
 
#if defined(_MSC_VER)
/* 'type cast' : conversion from 'int' to 'HANDLE' of greater size */
#pragma warning(disable : 4306)
/* conditional expression is constant: introduced by FD_SET(..) */
#pragma warning(disable : 4127)
/* non-constant aggregate initializer: issued due to missing C99 support */
#pragma warning(disable : 4204)
/* padding added after data member */
#pragma warning(disable : 4820)
/* not defined as a preprocessor macro, replacing with '0' for '#if/#elif' */
#pragma warning(disable : 4668)
/* no function prototype given: converting '()' to '(void)' */
#pragma warning(disable : 4255)
/* function has been selected for automatic inline expansion */
#pragma warning(disable : 4711)
#endif
 
 
/* This code uses static_assert to check some conditions.
 * Unfortunately some compilers still do not support it, so we have a
 * replacement function here. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ > 201100L
#define mg_static_assert _Static_assert
#elif defined(__cplusplus) && __cplusplus >= 201103L
#define mg_static_assert static_assert
#else
char static_assert_replacement[1];
#define mg_static_assert(cond, txt)                                            \
   extern char static_assert_replacement[(cond) ? 1 : -1]
#endif
 
mg_static_assert(sizeof(int) == 4 || sizeof(int) == 8,
                 "int data type size check");
mg_static_assert(sizeof(void *) == 4 || sizeof(void *) == 8,
                 "pointer data type size check");
mg_static_assert(sizeof(void *) >= sizeof(int), "data type size check");
 
 
/* Select queue implementation. Diagnosis features originally only implemented
 * for the "ALTERNATIVE_QUEUE" have been ported to the previous queue
 * implementation (NO_ALTERNATIVE_QUEUE) as well. The new configuration value
 * "CONNECTION_QUEUE_SIZE" is only available for the previous queue
 * implementation, since the queue length is independent from the number of
 * worker threads there, while the new queue is one element per worker thread.
 *
 */
#if defined(NO_ALTERNATIVE_QUEUE) && defined(ALTERNATIVE_QUEUE)
/* The queues are exclusive or - only one can be used. */
#error                                                                         \
    "Define ALTERNATIVE_QUEUE or NO_ALTERNATIVE_QUEUE (or none of them), but not both"
#endif
#if !defined(NO_ALTERNATIVE_QUEUE) && !defined(ALTERNATIVE_QUEUE)
/* Use a default implementation */
#define NO_ALTERNATIVE_QUEUE
#endif
 
#if defined(NO_FILESYSTEMS) && !defined(NO_FILES)
/* File system access:
 * NO_FILES = do not serve any files from the file system automatically.
 * However, with NO_FILES CivetWeb may still write log files, read access
 * control files, default error page files or use API functions like
 * mg_send_file in callbacks to send files from the server local
 * file system.
 * NO_FILES only disables the automatic mapping between URLs and local
 * file names.
 * NO_FILESYSTEM = do not access any file at all. Useful for embedded
 * devices without file system. Logging to files in not available
 * (use callbacks instead) and API functions like mg_send_file are not
 * available.
 * If NO_FILESYSTEM is set, NO_FILES must be set as well.
 */
#error "Inconsistent build flags, NO_FILESYSTEMS requires NO_FILES"
#endif
 
/* DTL -- including winsock2.h works better if lean and mean */
#if !defined(WIN32_LEAN_AND_MEAN)
#define WIN32_LEAN_AND_MEAN
#endif
 
#if defined(__SYMBIAN32__)
/* According to https://en.wikipedia.org/wiki/Symbian#History,
 * Symbian is no longer maintained since 2014-01-01.
 * Support for Symbian has been removed from CivetWeb
 */
#error "Symbian is no longer maintained. CivetWeb no longer supports Symbian."
#endif /* __SYMBIAN32__ */
 
#if defined(__ZEPHYR__)
#include <time.h>
 
#include <ctype.h>
#include <net/socket.h>
#include <posix/pthread.h>
#include <posix/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zephyr.h>
 
#include <fcntl.h>
 
#include <libc_extensions.h>
 
/* Max worker threads is the max of pthreads minus the main application thread
 * and minus the main civetweb thread, thus -2
 */
#define MAX_WORKER_THREADS (CONFIG_MAX_PTHREAD_COUNT - 2)
 
#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
#define ZEPHYR_STACK_SIZE USE_STACK_SIZE
#else
#define ZEPHYR_STACK_SIZE (1024 * 16)
#endif
 
K_THREAD_STACK_DEFINE(civetweb_main_stack, ZEPHYR_STACK_SIZE);
K_THREAD_STACK_ARRAY_DEFINE(civetweb_worker_stacks,
                            MAX_WORKER_THREADS,
                            ZEPHYR_STACK_SIZE);
 
static int zephyr_worker_stack_index;
 
#endif
 
#if !defined(CIVETWEB_HEADER_INCLUDED)
/* Include the header file here, so the CivetWeb interface is defined for the
 * entire implementation, including the following forward definitions. */
#include "civetweb.h"
#endif
 
#if !defined(DEBUG_TRACE)
#if defined(DEBUG)
static void DEBUG_TRACE_FUNC(const char *func,
                             unsigned line,
                             PRINTF_FORMAT_STRING(const char *fmt),
                             ...) PRINTF_ARGS(3, 4);
 
#define DEBUG_TRACE(fmt, ...)                                                  \
   DEBUG_TRACE_FUNC(__func__, __LINE__, fmt, __VA_ARGS__)
 
#define NEED_DEBUG_TRACE_FUNC
#if !defined(DEBUG_TRACE_STREAM)
#define DEBUG_TRACE_STREAM stdout
#endif
 
#else
#define DEBUG_TRACE(fmt, ...)                                                  \
   do {                                                                       \
   } while (0)
#endif /* DEBUG */
#endif /* DEBUG_TRACE */
 
 
#if !defined(DEBUG_ASSERT)
#if defined(DEBUG)
#include <stdlib.h>
#define DEBUG_ASSERT(cond)                                                     \
   do {                                                                       \
      if (!(cond)) {                                                         \
         DEBUG_TRACE("ASSERTION FAILED: %s", #cond);                        \
         exit(2); /* Exit with error */                                     \
      }                                                                      \
   } while (0)
#else
#define DEBUG_ASSERT(cond)
#endif /* DEBUG */
#endif
 
 
#if defined(__GNUC__) && defined(GCC_INSTRUMENTATION)
void __cyg_profile_func_enter(void *this_fn, void *call_site)
    __attribute__((no_instrument_function));
 
void __cyg_profile_func_exit(void *this_fn, void *call_site)
    __attribute__((no_instrument_function));
 
void
__cyg_profile_func_enter(void *this_fn, void *call_site)
{
   if ((void *)this_fn != (void *)printf) {
      printf("E %p %p\n", this_fn, call_site);
   }
}
 
void
__cyg_profile_func_exit(void *this_fn, void *call_site)
{
   if ((void *)this_fn != (void *)printf) {
      printf("X %p %p\n", this_fn, call_site);
   }
}
#endif
 
 
#if !defined(IGNORE_UNUSED_RESULT)
#define IGNORE_UNUSED_RESULT(a) ((void)((a) && 1))
#endif
 
 
#if defined(__GNUC__) || defined(__MINGW32__)
 
/* GCC unused function attribute seems fundamentally broken.
 * Several attempts to tell the compiler "THIS FUNCTION MAY BE USED
 * OR UNUSED" for individual functions failed.
 * Either the compiler creates an "unused-function" warning if a
 * function is not marked with __attribute__((unused)).
 * On the other hand, if the function is marked with this attribute,
 * but is used, the compiler raises a completely idiotic
 * "used-but-marked-unused" warning - and
 *   #pragma GCC diagnostic ignored "-Wused-but-marked-unused"
 * raises error: unknown option after "#pragma GCC diagnostic".
 * Disable this warning completely, until the GCC guys sober up
 * again.
 */
 
#pragma GCC diagnostic ignored "-Wunused-function"
 
#define FUNCTION_MAY_BE_UNUSED /* __attribute__((unused)) */
 
#else
#define FUNCTION_MAY_BE_UNUSED
#endif
 
 
/* Some ANSI #includes are not available on Windows CE and Zephyr */
#if !defined(_WIN32_WCE) && !defined(__ZEPHYR__)
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#endif /* !_WIN32_WCE */
 
 
#if defined(__clang__)
/* When using -Weverything, clang does not accept it's own headers
 * in a release build configuration. Disable what is too much in
 * -Weverything. */
#pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
#endif
 
#if defined(__GNUC__) || defined(__MINGW32__)
/* Who on earth came to the conclusion, using __DATE__ should rise
 * an "expansion of date or time macro is not reproducible"
 * warning. That's exactly what was intended by using this macro.
 * Just disable this nonsense warning. */
 
/* And disabling them does not work either:
 * #pragma clang diagnostic ignored "-Wno-error=date-time"
 * #pragma clang diagnostic ignored "-Wdate-time"
 * So we just have to disable ALL warnings for some lines
 * of code.
 * This seems to be a known GCC bug, not resolved since 2012:
 * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53431
 */
#endif
 
 
#if defined(__MACH__) /* Apple OSX section */
 
#if defined(__clang__)
#if (__clang_major__ == 3) && ((__clang_minor__ == 7) || (__clang_minor__ == 8))
/* Avoid warnings for Xcode 7. It seems it does no longer exist in Xcode 8 */
#pragma clang diagnostic ignored "-Wno-reserved-id-macro"
#pragma clang diagnostic ignored "-Wno-keyword-macro"
#endif
#endif
 
#ifndef CLOCK_MONOTONIC
#define CLOCK_MONOTONIC (1)
#endif
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME (2)
#endif
 
#include <mach/clock.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <sys/errno.h>
#include <sys/time.h>
 
/* clock_gettime is not implemented on OSX prior to 10.12 */
static int
_civet_clock_gettime(int clk_id, struct timespec *t)
{
   memset(t, 0, sizeof(*t));
   if (clk_id == CLOCK_REALTIME) {
      struct timeval now;
      int rv = gettimeofday(&now, NULL);
      if (rv) {
         return rv;
      }
      t->tv_sec = now.tv_sec;
      t->tv_nsec = now.tv_usec * 1000;
      return 0;
 
   } else if (clk_id == CLOCK_MONOTONIC) {
      static uint64_t clock_start_time = 0;
      static mach_timebase_info_data_t timebase_ifo = {0, 0};
 
      uint64_t now = mach_absolute_time();
 
      if (clock_start_time == 0) {
         kern_return_t mach_status = mach_timebase_info(&timebase_ifo);
         DEBUG_ASSERT(mach_status == KERN_SUCCESS);
 
         /* appease "unused variable" warning for release builds */
         (void)mach_status;
 
         clock_start_time = now;
      }
 
      now = (uint64_t)((double)(now - clock_start_time)
                       * (double)timebase_ifo.numer
                       / (double)timebase_ifo.denom);
 
      t->tv_sec = now / 1000000000;
      t->tv_nsec = now % 1000000000;
      return 0;
   }
   return -1; /* EINVAL - Clock ID is unknown */
}
 
/* if clock_gettime is declared, then __CLOCK_AVAILABILITY will be defined */
#if defined(__CLOCK_AVAILABILITY)
/* If we compiled with Mac OSX 10.12 or later, then clock_gettime will be
 * declared but it may be NULL at runtime. So we need to check before using
 * it. */
static int
_civet_safe_clock_gettime(int clk_id, struct timespec *t)
{
   if (clock_gettime) {
      return clock_gettime(clk_id, t);
   }
   return _civet_clock_gettime(clk_id, t);
}
#define clock_gettime _civet_safe_clock_gettime
#else
#define clock_gettime _civet_clock_gettime
#endif
 
#endif
 
 
#if !defined(_WIN32)
/* Unix might return different error codes indicating to try again.
 * For Linux EAGAIN==EWOULDBLOCK, maybe EAGAIN!=EWOULDBLOCK is history from
 * decades ago, but better check both and let the compile optimize it. */
#define ERROR_TRY_AGAIN(err)                                                   \
   (((err) == EAGAIN) || ((err) == EWOULDBLOCK) || ((err) == EINTR))
#endif
 
#if defined(USE_ZLIB)
#include "zconf.h"
#include "zlib.h"
#endif
 
 
/********************************************************************/
/* CivetWeb configuration defines */
/********************************************************************/
 
/* Maximum number of threads that can be configured.
 * The number of threads actually created depends on the "num_threads"
 * configuration parameter, but this is the upper limit. */
#if !defined(MAX_WORKER_THREADS)
#define MAX_WORKER_THREADS (1024 * 64) /* in threads (count) */
#endif
 
/* Timeout interval for select/poll calls.
 * The timeouts depend on "*_timeout_ms" configuration values, but long
 * timeouts are split into timouts as small as SOCKET_TIMEOUT_QUANTUM.
 * This reduces the time required to stop the server. */
#if !defined(SOCKET_TIMEOUT_QUANTUM)
#define SOCKET_TIMEOUT_QUANTUM (2000) /* in ms */
#endif
 
/* Do not try to compress files smaller than this limit. */
#if !defined(MG_FILE_COMPRESSION_SIZE_LIMIT)
#define MG_FILE_COMPRESSION_SIZE_LIMIT (1024) /* in bytes */
#endif
 
#if !defined(PASSWORDS_FILE_NAME)
#define PASSWORDS_FILE_NAME ".htpasswd"
#endif
 
/* Initial buffer size for all CGI environment variables. In case there is
 * not enough space, another block is allocated. */
#if !defined(CGI_ENVIRONMENT_SIZE)
#define CGI_ENVIRONMENT_SIZE (4096) /* in bytes */
#endif
 
/* Maximum number of environment variables. */
#if !defined(MAX_CGI_ENVIR_VARS)
#define MAX_CGI_ENVIR_VARS (256) /* in variables (count) */
#endif
 
/* General purpose buffer size. */
#if !defined(MG_BUF_LEN) /* in bytes */
#define MG_BUF_LEN (1024 * 8)
#endif
 
 
/********************************************************************/
 
/* Helper makros */
#if !defined(ARRAY_SIZE)
#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
#endif
 
#include <stdint.h>
 
/* Standard defines */
#if !defined(INT64_MAX)
#define INT64_MAX (9223372036854775807)
#endif
 
#define SHUTDOWN_RD (0)
#define SHUTDOWN_WR (1)
#define SHUTDOWN_BOTH (2)
 
mg_static_assert(MAX_WORKER_THREADS >= 1,
                 "worker threads must be a positive number");
 
mg_static_assert(sizeof(size_t) == 4 || sizeof(size_t) == 8,
                 "size_t data type size check");
 
 
#if defined(_WIN32) /* WINDOWS include block */
#include <malloc.h> /* *alloc( */
#include <stdlib.h> /* *alloc( */
#include <time.h>   /* struct timespec */
#include <windows.h>
#include <winsock2.h> /* DTL add for SO_EXCLUSIVE */
#include <ws2tcpip.h>
 
typedef const char *SOCK_OPT_TYPE;
 
/* For a detailed description of these *_PATH_MAX defines, see
 * https://github.com/civetweb/civetweb/issues/937. */
 
/* UTF8_PATH_MAX is a char buffer size for 259 BMP characters in UTF-8 plus
 * null termination, rounded up to the next 4 bytes boundary */
#define UTF8_PATH_MAX (3 * 260)
/* UTF16_PATH_MAX is the 16-bit wchar_t buffer size required for 259 BMP
 * characters plus termination. (Note: wchar_t is 16 bit on Windows) */
#define UTF16_PATH_MAX (260)
 
#if !defined(_IN_PORT_T)
#if !defined(in_port_t)
#define in_port_t u_short
#endif
#endif
 
#if defined(_WIN32_WCE)
#error "WinCE support has ended"
#endif
 
#include <direct.h>
#include <io.h>
#include <process.h>
 
 
#define MAKEUQUAD(lo, hi)                                                      \
   ((uint64_t)(((uint32_t)(lo)) | ((uint64_t)((uint32_t)(hi))) << 32))
#define RATE_DIFF (10000000) /* 100 nsecs */
#define EPOCH_DIFF (MAKEUQUAD(0xd53e8000, 0x019db1de))
#define SYS2UNIX_TIME(lo, hi)                                                  \
   ((time_t)((MAKEUQUAD((lo), (hi)) - EPOCH_DIFF) / RATE_DIFF))
 
/* Visual Studio 6 does not know __func__ or __FUNCTION__
 * The rest of MS compilers use __FUNCTION__, not C99 __func__
 * Also use _strtoui64 on modern M$ compilers */
#if defined(_MSC_VER)
#if (_MSC_VER < 1300)
#define STRX(x) #x
#define STR(x) STRX(x)
#define __func__ __FILE__ ":" STR(__LINE__)
#define strtoull(x, y, z) ((unsigned __int64)_atoi64(x))
#define strtoll(x, y, z) (_atoi64(x))
#else
#define __func__ __FUNCTION__
#define strtoull(x, y, z) (_strtoui64(x, y, z))
#define strtoll(x, y, z) (_strtoi64(x, y, z))
#endif
#endif /* _MSC_VER */
 
#define ERRNO ((int)(GetLastError()))
#define NO_SOCKLEN_T
 
 
#if defined(_WIN64) || defined(__MINGW64__)
#if !defined(SSL_LIB)
 
#if defined(OPENSSL_API_3_0)
#define SSL_LIB "libssl-3-x64.dll"
#define CRYPTO_LIB "libcrypto-3-x64.dll"
#endif
 
#if defined(OPENSSL_API_1_1)
#define SSL_LIB "libssl-1_1-x64.dll"
#define CRYPTO_LIB "libcrypto-1_1-x64.dll"
#endif /* OPENSSL_API_1_1 */
 
#if defined(OPENSSL_API_1_0)
#define SSL_LIB "ssleay64.dll"
#define CRYPTO_LIB "libeay64.dll"
#endif /* OPENSSL_API_1_0 */
 
#endif
#else /* defined(_WIN64) || defined(__MINGW64__) */
#if !defined(SSL_LIB)
 
#if defined(OPENSSL_API_3_0)
#define SSL_LIB "libssl-3.dll"
#define CRYPTO_LIB "libcrypto-3.dll"
#endif
 
#if defined(OPENSSL_API_1_1)
#define SSL_LIB "libssl-1_1.dll"
#define CRYPTO_LIB "libcrypto-1_1.dll"
#endif /* OPENSSL_API_1_1 */
 
#if defined(OPENSSL_API_1_0)
#define SSL_LIB "ssleay32.dll"
#define CRYPTO_LIB "libeay32.dll"
#endif /* OPENSSL_API_1_0 */
 
#endif /* SSL_LIB */
#endif /* defined(_WIN64) || defined(__MINGW64__) */
 
 
#define O_NONBLOCK (0)
#if !defined(W_OK)
#define W_OK (2) /* http://msdn.microsoft.com/en-us/library/1w06ktdy.aspx */
#endif
#define _POSIX_
#define INT64_FMT "I64d"
#define UINT64_FMT "I64u"
 
#define WINCDECL __cdecl
#define vsnprintf_impl _vsnprintf
#define access _access
#define mg_sleep(x) (Sleep(x))
 
#define pipe(x) _pipe(x, MG_BUF_LEN, _O_BINARY)
#if !defined(popen)
#define popen(x, y) (_popen(x, y))
#endif
#if !defined(pclose)
#define pclose(x) (_pclose(x))
#endif
#define close(x) (_close(x))
#define dlsym(x, y) (GetProcAddress((HINSTANCE)(x), (y)))
#define RTLD_LAZY (0)
#define fseeko(x, y, z) ((_lseeki64(_fileno(x), (y), (z)) == -1) ? -1 : 0)
#define fdopen(x, y) (_fdopen((x), (y)))
#define write(x, y, z) (_write((x), (y), (unsigned)z))
#define read(x, y, z) (_read((x), (y), (unsigned)z))
#define flockfile(x) ((void)pthread_mutex_lock(&global_log_file_lock))
#define funlockfile(x) ((void)pthread_mutex_unlock(&global_log_file_lock))
#define sleep(x) (Sleep((x)*1000))
#define rmdir(x) (_rmdir(x))
#if defined(_WIN64) || !defined(__MINGW32__)
/* Only MinGW 32 bit is missing this function */
#define timegm(x) (_mkgmtime(x))
#else
time_t timegm(struct tm *tm);
#define NEED_TIMEGM
#endif
 
 
#if !defined(fileno)
#define fileno(x) (_fileno(x))
#endif /* !fileno MINGW #defines fileno */
 
typedef struct {
   CRITICAL_SECTION sec; /* Immovable */
} pthread_mutex_t;
typedef DWORD pthread_key_t;
typedef HANDLE pthread_t;
typedef struct {
   pthread_mutex_t threadIdSec;
   struct mg_workerTLS *waiting_thread; /* The chain of threads */
} pthread_cond_t;
 
#if !defined(__clockid_t_defined)
typedef DWORD clockid_t;
#endif
#if !defined(CLOCK_MONOTONIC)
#define CLOCK_MONOTONIC (1)
#endif
#if !defined(CLOCK_REALTIME)
#define CLOCK_REALTIME (2)
#endif
#if !defined(CLOCK_THREAD)
#define CLOCK_THREAD (3)
#endif
#if !defined(CLOCK_PROCESS)
#define CLOCK_PROCESS (4)
#endif
 
 
#if defined(_MSC_VER) && (_MSC_VER >= 1900)
#define _TIMESPEC_DEFINED
#endif
#if !defined(_TIMESPEC_DEFINED)
struct timespec {
   time_t tv_sec; /* seconds */
   long tv_nsec;  /* nanoseconds */
};
#endif
 
#if !defined(WIN_PTHREADS_TIME_H)
#define MUST_IMPLEMENT_CLOCK_GETTIME
#endif
 
#if defined(MUST_IMPLEMENT_CLOCK_GETTIME)
#define clock_gettime mg_clock_gettime
static int
clock_gettime(clockid_t clk_id, struct timespec *tp)
{
   FILETIME ft;
   ULARGE_INTEGER li, li2;
   BOOL ok = FALSE;
   double d;
   static double perfcnt_per_sec = 0.0;
   static BOOL initialized = FALSE;
 
   if (!initialized) {
      QueryPerformanceFrequency((LARGE_INTEGER *)&li);
      perfcnt_per_sec = 1.0 / li.QuadPart;
      initialized = TRUE;
   }
 
   if (tp) {
      memset(tp, 0, sizeof(*tp));
 
      if (clk_id == CLOCK_REALTIME) {
 
         /* BEGIN: CLOCK_REALTIME = wall clock (date and time) */
         GetSystemTimeAsFileTime(&ft);
         li.LowPart = ft.dwLowDateTime;
         li.HighPart = ft.dwHighDateTime;
         li.QuadPart -= 116444736000000000; /* 1.1.1970 in filedate */
         tp->tv_sec = (time_t)(li.QuadPart / 10000000);
         tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
         ok = TRUE;
         /* END: CLOCK_REALTIME */
 
      } else if (clk_id == CLOCK_MONOTONIC) {
 
         /* BEGIN: CLOCK_MONOTONIC = stopwatch (time differences) */
         QueryPerformanceCounter((LARGE_INTEGER *)&li);
         d = li.QuadPart * perfcnt_per_sec;
         tp->tv_sec = (time_t)d;
         d -= (double)tp->tv_sec;
         tp->tv_nsec = (long)(d * 1.0E9);
         ok = TRUE;
         /* END: CLOCK_MONOTONIC */
 
      } else if (clk_id == CLOCK_THREAD) {
 
         /* BEGIN: CLOCK_THREAD = CPU usage of thread */
         FILETIME t_create, t_exit, t_kernel, t_user;
         if (GetThreadTimes(GetCurrentThread(),
                            &t_create,
                            &t_exit,
                            &t_kernel,
                            &t_user)) {
            li.LowPart = t_user.dwLowDateTime;
            li.HighPart = t_user.dwHighDateTime;
            li2.LowPart = t_kernel.dwLowDateTime;
            li2.HighPart = t_kernel.dwHighDateTime;
            li.QuadPart += li2.QuadPart;
            tp->tv_sec = (time_t)(li.QuadPart / 10000000);
            tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
            ok = TRUE;
         }
         /* END: CLOCK_THREAD */
 
      } else if (clk_id == CLOCK_PROCESS) {
 
         /* BEGIN: CLOCK_PROCESS = CPU usage of process */
         FILETIME t_create, t_exit, t_kernel, t_user;
         if (GetProcessTimes(GetCurrentProcess(),
                             &t_create,
                             &t_exit,
                             &t_kernel,
                             &t_user)) {
            li.LowPart = t_user.dwLowDateTime;
            li.HighPart = t_user.dwHighDateTime;
            li2.LowPart = t_kernel.dwLowDateTime;
            li2.HighPart = t_kernel.dwHighDateTime;
            li.QuadPart += li2.QuadPart;
            tp->tv_sec = (time_t)(li.QuadPart / 10000000);
            tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
            ok = TRUE;
         }
         /* END: CLOCK_PROCESS */
 
      } else {
 
         /* BEGIN: unknown clock */
         /* ok = FALSE; already set by init */
         /* END: unknown clock */
      }
   }
 
   return ok ? 0 : -1;
}
#endif
 
 
#define pid_t HANDLE /* MINGW typedefs pid_t to int. Using #define here. */
 
static int pthread_mutex_lock(pthread_mutex_t *);
static int pthread_mutex_unlock(pthread_mutex_t *);
static void path_to_unicode(const struct mg_connection *conn,
                            const char *path,
                            wchar_t *wbuf,
                            size_t wbuf_len);
 
/* All file operations need to be rewritten to solve #246. */
 
struct mg_file;
 
static const char *mg_fgets(char *buf, size_t size, struct mg_file *filep);
 
 
/* POSIX dirent interface */
struct dirent {
   char d_name[UTF8_PATH_MAX];
};
 
typedef struct DIR {
   HANDLE handle;
   WIN32_FIND_DATAW info;
   struct dirent result;
} DIR;
 
#if defined(HAVE_POLL)
#define mg_pollfd pollfd
#else
struct mg_pollfd {
   SOCKET fd;
   short events;
   short revents;
};
#endif
 
/* Mark required libraries */
#if defined(_MSC_VER)
#pragma comment(lib, "Ws2_32.lib")
#endif
 
#else /* defined(_WIN32) - WINDOWS vs UNIX include block */
 
#include <inttypes.h>
 
/* Linux & co. internally use UTF8 */
#define UTF8_PATH_MAX (PATH_MAX)
 
typedef const void *SOCK_OPT_TYPE;
 
#if defined(ANDROID)
typedef unsigned short int in_port_t;
#endif
 
#if !defined(__ZEPHYR__)
#include <arpa/inet.h>
#include <ctype.h>
#include <dirent.h>
#include <grp.h>
#include <limits.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <pthread.h>
#include <pwd.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#if defined(USE_X_DOM_SOCKET)
#include <sys/un.h>
#endif
#endif
 
#define vsnprintf_impl vsnprintf
 
#if !defined(NO_SSL_DL) && !defined(NO_SSL)
#include <dlfcn.h>
#endif
 
#if defined(__MACH__)
#define SSL_LIB "libssl.dylib"
#define CRYPTO_LIB "libcrypto.dylib"
#else
#if !defined(SSL_LIB)
#define SSL_LIB "libssl.so"
#endif
#if !defined(CRYPTO_LIB)
#define CRYPTO_LIB "libcrypto.so"
#endif
#endif
#if !defined(O_BINARY)
#define O_BINARY (0)
#endif /* O_BINARY */
#define closesocket(a) (close(a))
#define mg_mkdir(conn, path, mode) (mkdir(path, mode))
#define mg_remove(conn, x) (remove(x))
#define mg_sleep(x) (usleep((x)*1000))
#define mg_opendir(conn, x) (opendir(x))
#define mg_closedir(x) (closedir(x))
#define mg_readdir(x) (readdir(x))
#define ERRNO (errno)
#define INVALID_SOCKET (-1)
#define INT64_FMT PRId64
#define UINT64_FMT PRIu64
typedef int SOCKET;
#define WINCDECL
 
#if defined(__hpux)
/* HPUX 11 does not have monotonic, fall back to realtime */
#if !defined(CLOCK_MONOTONIC)
#define CLOCK_MONOTONIC CLOCK_REALTIME
#endif
 
/* HPUX defines socklen_t incorrectly as size_t which is 64bit on
 * Itanium.  Without defining _XOPEN_SOURCE or _XOPEN_SOURCE_EXTENDED
 * the prototypes use int* rather than socklen_t* which matches the
 * actual library expectation.  When called with the wrong size arg
 * accept() returns a zero client inet addr and check_acl() always
 * fails.  Since socklen_t is widely used below, just force replace
 * their typedef with int. - DTL
 */
#define socklen_t int
#endif /* hpux */
 
#define mg_pollfd pollfd
 
#endif /* defined(_WIN32) - WINDOWS vs UNIX include block */
 
/* In case our C library is missing "timegm", provide an implementation */
#if defined(NEED_TIMEGM)
static inline int
is_leap(int y)
{
   return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
 
static inline int
count_leap(int y)
{
   return (y - 1969) / 4 - (y - 1901) / 100 + (y - 1601) / 400;
}
 
time_t
timegm(struct tm *tm)
{
   static const unsigned short ydays[] = {
       0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
   int year = tm->tm_year + 1900;
   int mon = tm->tm_mon;
   int mday = tm->tm_mday - 1;
   int hour = tm->tm_hour;
   int min = tm->tm_min;
   int sec = tm->tm_sec;
 
   if (year < 1970 || mon < 0 || mon > 11 || mday < 0
       || (mday >= ydays[mon + 1] - ydays[mon]
                       + (mon == 1 && is_leap(year) ? 1 : 0))
       || hour < 0 || hour > 23 || min < 0 || min > 59 || sec < 0 || sec > 60)
      return -1;
 
   time_t res = year - 1970;
   res *= 365;
   res += mday;
   res += ydays[mon] + (mon > 1 && is_leap(year) ? 1 : 0);
   res += count_leap(year);
 
   res *= 24;
   res += hour;
   res *= 60;
   res += min;
   res *= 60;
   res += sec;
   return res;
}
#endif /* NEED_TIMEGM */
 
 
/* va_copy should always be a macro, C99 and C++11 - DTL */
#if !defined(va_copy)
#define va_copy(x, y) ((x) = (y))
#endif
 
 
#if defined(_WIN32)
/* Create substitutes for POSIX functions in Win32. */
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
 
static pthread_mutex_t global_log_file_lock;
 
FUNCTION_MAY_BE_UNUSED
static DWORD
pthread_self(void)
{
   return GetCurrentThreadId();
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_key_create(
    pthread_key_t *key,
    void (*_ignored)(void *) /* destructor not supported for Windows */
)
{
   (void)_ignored;
 
   if ((key != 0)) {
      *key = TlsAlloc();
      return (*key != TLS_OUT_OF_INDEXES) ? 0 : -1;
   }
   return -2;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_key_delete(pthread_key_t key)
{
   return TlsFree(key) ? 0 : 1;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_setspecific(pthread_key_t key, void *value)
{
   return TlsSetValue(key, value) ? 0 : 1;
}
 
 
FUNCTION_MAY_BE_UNUSED
static void *
pthread_getspecific(pthread_key_t key)
{
   return TlsGetValue(key);
}
 
#if defined(GCC_DIAGNOSTIC)
/* Enable unused function warning again */
#pragma GCC diagnostic pop
#endif
 
static struct pthread_mutex_undefined_struct *pthread_mutex_attr = NULL;
#else
static pthread_mutexattr_t pthread_mutex_attr;
#endif /* _WIN32 */
 
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif /* defined(GCC_DIAGNOSTIC) */
#if defined(__clang__)
/* Show no warning in case system functions are not used. */
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
#endif
 
static pthread_mutex_t global_lock_mutex;
 
 
FUNCTION_MAY_BE_UNUSED
static void
mg_global_lock(void)
{
   (void)pthread_mutex_lock(&global_lock_mutex);
}
 
 
FUNCTION_MAY_BE_UNUSED
static void
mg_global_unlock(void)
{
   (void)pthread_mutex_unlock(&global_lock_mutex);
}
 
 
#if defined(_WIN64)
mg_static_assert(SIZE_MAX == 0xFFFFFFFFFFFFFFFFu, "Mismatch for atomic types");
#elif defined(_WIN32)
mg_static_assert(SIZE_MAX == 0xFFFFFFFFu, "Mismatch for atomic types");
#endif
 
 
/* Atomic functions working on ptrdiff_t ("signed size_t").
 * Operations: Increment, Decrement, Add, Maximum.
 * Up to size_t, they do not an atomic "load" operation.
 */
FUNCTION_MAY_BE_UNUSED
static ptrdiff_t
mg_atomic_inc(volatile ptrdiff_t *addr)
{
   ptrdiff_t ret;
 
#if defined(_WIN64) && !defined(NO_ATOMICS)
   ret = InterlockedIncrement64(addr);
#elif defined(_WIN32) && !defined(NO_ATOMICS)
   ret = InterlockedIncrement(addr);
#elif defined(__GNUC__)                                                        \
    && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))           \
    && !defined(NO_ATOMICS)
   ret = __sync_add_and_fetch(addr, 1);
#else
   mg_global_lock();
   ret = (++(*addr));
   mg_global_unlock();
#endif
   return ret;
}
 
 
FUNCTION_MAY_BE_UNUSED
static ptrdiff_t
mg_atomic_dec(volatile ptrdiff_t *addr)
{
   ptrdiff_t ret;
 
#if defined(_WIN64) && !defined(NO_ATOMICS)
   ret = InterlockedDecrement64(addr);
#elif defined(_WIN32) && !defined(NO_ATOMICS)
   ret = InterlockedDecrement(addr);
#elif defined(__GNUC__)                                                        \
    && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))           \
    && !defined(NO_ATOMICS)
   ret = __sync_sub_and_fetch(addr, 1);
#else
   mg_global_lock();
   ret = (--(*addr));
   mg_global_unlock();
#endif
   return ret;
}
 
 
#if defined(USE_SERVER_STATS) || defined(STOP_FLAG_NEEDS_LOCK)
static ptrdiff_t
mg_atomic_add(volatile ptrdiff_t *addr, ptrdiff_t value)
{
   ptrdiff_t ret;
 
#if defined(_WIN64) && !defined(NO_ATOMICS)
   ret = InterlockedAdd64(addr, value);
#elif defined(_WIN32) && !defined(NO_ATOMICS)
   ret = InterlockedExchangeAdd(addr, value) + value;
#elif defined(__GNUC__)                                                        \
    && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))           \
    && !defined(NO_ATOMICS)
   ret = __sync_add_and_fetch(addr, value);
#else
   mg_global_lock();
   *addr += value;
   ret = (*addr);
   mg_global_unlock();
#endif
   return ret;
}
 
 
FUNCTION_MAY_BE_UNUSED
static ptrdiff_t
mg_atomic_compare_and_swap(volatile ptrdiff_t *addr,
                           ptrdiff_t oldval,
                           ptrdiff_t newval)
{
   ptrdiff_t ret;
 
#if defined(_WIN64) && !defined(NO_ATOMICS)
   ret = InterlockedCompareExchange64(addr, newval, oldval);
#elif defined(_WIN32) && !defined(NO_ATOMICS)
   ret = InterlockedCompareExchange(addr, newval, oldval);
#elif defined(__GNUC__)                                                        \
    && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))           \
    && !defined(NO_ATOMICS)
   ret = __sync_val_compare_and_swap(addr, oldval, newval);
#else
   mg_global_lock();
   ret = *addr;
   if ((ret != newval) && (ret == oldval)) {
      *addr = newval;
   }
   mg_global_unlock();
#endif
   return ret;
}
 
 
static void
mg_atomic_max(volatile ptrdiff_t *addr, ptrdiff_t value)
{
   register ptrdiff_t tmp = *addr;
 
#if defined(_WIN64) && !defined(NO_ATOMICS)
   while (tmp < value) {
      tmp = InterlockedCompareExchange64(addr, value, tmp);
   }
#elif defined(_WIN32) && !defined(NO_ATOMICS)
   while (tmp < value) {
      tmp = InterlockedCompareExchange(addr, value, tmp);
   }
#elif defined(__GNUC__)                                                        \
    && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))           \
    && !defined(NO_ATOMICS)
   while (tmp < value) {
      tmp = __sync_val_compare_and_swap(addr, tmp, value);
   }
#else
   mg_global_lock();
   if (*addr < value) {
      *addr = value;
   }
   mg_global_unlock();
#endif
}
 
 
static int64_t
mg_atomic_add64(volatile int64_t *addr, int64_t value)
{
   int64_t ret;
 
#if defined(_WIN64) && !defined(NO_ATOMICS)
   ret = InterlockedAdd64(addr, value);
#elif defined(_WIN32) && !defined(NO_ATOMICS)
   ret = InterlockedExchangeAdd64(addr, value) + value;
#elif defined(__GNUC__)                                                        \
    && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))           \
    && !defined(NO_ATOMICS)
   ret = __sync_add_and_fetch(addr, value);
#else
   mg_global_lock();
   *addr += value;
   ret = (*addr);
   mg_global_unlock();
#endif
   return ret;
}
#endif
 
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic pop
#endif /* defined(GCC_DIAGNOSTIC) */
#if defined(__clang__)
/* Show no warning in case system functions are not used. */
#pragma clang diagnostic pop
#endif
 
 
#if defined(USE_SERVER_STATS)
 
struct mg_memory_stat {
   volatile ptrdiff_t totalMemUsed;
   volatile ptrdiff_t maxMemUsed;
   volatile ptrdiff_t blockCount;
};
 
 
static struct mg_memory_stat *get_memory_stat(struct mg_context *ctx);
 
 
static void *
mg_malloc_ex(size_t size,
             struct mg_context *ctx,
             const char *file,
             unsigned line)
{
   void *data = malloc(size + 2 * sizeof(uintptr_t));
   void *memory = 0;
   struct mg_memory_stat *mstat = get_memory_stat(ctx);
 
#if defined(MEMORY_DEBUGGING)
   char mallocStr[256];
#else
   (void)file;
   (void)line;
#endif
 
   if (data) {
      ptrdiff_t mmem = mg_atomic_add(&mstat->totalMemUsed, (ptrdiff_t)size);
      mg_atomic_max(&mstat->maxMemUsed, mmem);
 
      mg_atomic_inc(&mstat->blockCount);
      ((uintptr_t *)data)[0] = size;
      ((uintptr_t *)data)[1] = (uintptr_t)mstat;
      memory = (void *)(((char *)data) + 2 * sizeof(uintptr_t));
   }
 
#if defined(MEMORY_DEBUGGING)
   sprintf(mallocStr,
           "MEM: %p %5lu alloc   %7lu %4lu --- %s:%u\n",
           memory,
           (unsigned long)size,
           (unsigned long)mstat->totalMemUsed,
           (unsigned long)mstat->blockCount,
           file,
           line);
   DEBUG_TRACE("%s", mallocStr);
#endif
 
   return memory;
}
 
 
static void *
mg_calloc_ex(size_t count,
             size_t size,
             struct mg_context *ctx,
             const char *file,
             unsigned line)
{
   void *data = mg_malloc_ex(size * count, ctx, file, line);
 
   if (data) {
      memset(data, 0, size * count);
   }
   return data;
}
 
 
static void
mg_free_ex(void *memory, const char *file, unsigned line)
{
#if defined(MEMORY_DEBUGGING)
   char mallocStr[256];
#else
   (void)file;
   (void)line;
#endif
 
   if (memory) {
      void *data = (void *)(((char *)memory) - 2 * sizeof(uintptr_t));
      uintptr_t size = ((uintptr_t *)data)[0];
      struct mg_memory_stat *mstat =
          (struct mg_memory_stat *)(((uintptr_t *)data)[1]);
      mg_atomic_add(&mstat->totalMemUsed, -(ptrdiff_t)size);
      mg_atomic_dec(&mstat->blockCount);
 
#if defined(MEMORY_DEBUGGING)
      sprintf(mallocStr,
              "MEM: %p %5lu free    %7lu %4lu --- %s:%u\n",
              memory,
              (unsigned long)size,
              (unsigned long)mstat->totalMemUsed,
              (unsigned long)mstat->blockCount,
              file,
              line);
      DEBUG_TRACE("%s", mallocStr);
#endif
      free(data);
   }
}
 
 
static void *
mg_realloc_ex(void *memory,
              size_t newsize,
              struct mg_context *ctx,
              const char *file,
              unsigned line)
{
   void *data;
   void *_realloc;
   uintptr_t oldsize;
 
#if defined(MEMORY_DEBUGGING)
   char mallocStr[256];
#else
   (void)file;
   (void)line;
#endif
 
   if (newsize) {
      if (memory) {
         /* Reallocate existing block */
         struct mg_memory_stat *mstat;
         data = (void *)(((char *)memory) - 2 * sizeof(uintptr_t));
         oldsize = ((uintptr_t *)data)[0];
         mstat = (struct mg_memory_stat *)((uintptr_t *)data)[1];
         _realloc = realloc(data, newsize + 2 * sizeof(uintptr_t));
         if (_realloc) {
            data = _realloc;
            mg_atomic_add(&mstat->totalMemUsed, -(ptrdiff_t)oldsize);
#if defined(MEMORY_DEBUGGING)
            sprintf(mallocStr,
                    "MEM: %p %5lu r-free  %7lu %4lu --- %s:%u\n",
                    memory,
                    (unsigned long)oldsize,
                    (unsigned long)mstat->totalMemUsed,
                    (unsigned long)mstat->blockCount,
                    file,
                    line);
            DEBUG_TRACE("%s", mallocStr);
#endif
            mg_atomic_add(&mstat->totalMemUsed, (ptrdiff_t)newsize);
 
#if defined(MEMORY_DEBUGGING)
            sprintf(mallocStr,
                    "MEM: %p %5lu r-alloc %7lu %4lu --- %s:%u\n",
                    memory,
                    (unsigned long)newsize,
                    (unsigned long)mstat->totalMemUsed,
                    (unsigned long)mstat->blockCount,
                    file,
                    line);
            DEBUG_TRACE("%s", mallocStr);
#endif
            *(uintptr_t *)data = newsize;
            data = (void *)(((char *)data) + 2 * sizeof(uintptr_t));
         } else {
#if defined(MEMORY_DEBUGGING)
            DEBUG_TRACE("%s", "MEM: realloc failed\n");
#endif
            return _realloc;
         }
      } else {
         /* Allocate new block */
         data = mg_malloc_ex(newsize, ctx, file, line);
      }
   } else {
      /* Free existing block */
      data = 0;
      mg_free_ex(memory, file, line);
   }
 
   return data;
}
 
 
#define mg_malloc(a) mg_malloc_ex(a, NULL, __FILE__, __LINE__)
#define mg_calloc(a, b) mg_calloc_ex(a, b, NULL, __FILE__, __LINE__)
#define mg_realloc(a, b) mg_realloc_ex(a, b, NULL, __FILE__, __LINE__)
#define mg_free(a) mg_free_ex(a, __FILE__, __LINE__)
 
#define mg_malloc_ctx(a, c) mg_malloc_ex(a, c, __FILE__, __LINE__)
#define mg_calloc_ctx(a, b, c) mg_calloc_ex(a, b, c, __FILE__, __LINE__)
#define mg_realloc_ctx(a, b, c) mg_realloc_ex(a, b, c, __FILE__, __LINE__)
 
 
#else /* USE_SERVER_STATS */
 
 
static __inline void *
mg_malloc(size_t a)
{
   return malloc(a);
}
 
static __inline void *
mg_calloc(size_t a, size_t b)
{
   return calloc(a, b);
}
 
static __inline void *
mg_realloc(void *a, size_t b)
{
   return realloc(a, b);
}
 
static __inline void
mg_free(void *a)
{
   free(a);
}
 
#define mg_malloc_ctx(a, c) mg_malloc(a)
#define mg_calloc_ctx(a, b, c) mg_calloc(a, b)
#define mg_realloc_ctx(a, b, c) mg_realloc(a, b)
#define mg_free_ctx(a, c) mg_free(a)
 
#endif /* USE_SERVER_STATS */
 
 
static void mg_vsnprintf(const struct mg_connection *conn,
                         int *truncated,
                         char *buf,
                         size_t buflen,
                         const char *fmt,
                         va_list ap);
 
static void mg_snprintf(const struct mg_connection *conn,
                        int *truncated,
                        char *buf,
                        size_t buflen,
                        PRINTF_FORMAT_STRING(const char *fmt),
                        ...) PRINTF_ARGS(5, 6);
 
/* This following lines are just meant as a reminder to use the mg-functions
 * for memory management */
#if defined(malloc)
#undef malloc
#endif
#if defined(calloc)
#undef calloc
#endif
#if defined(realloc)
#undef realloc
#endif
#if defined(free)
#undef free
#endif
#if defined(snprintf)
#undef snprintf
#endif
#if defined(vsnprintf)
#undef vsnprintf
#endif
#define malloc DO_NOT_USE_THIS_FUNCTION__USE_mg_malloc
#define calloc DO_NOT_USE_THIS_FUNCTION__USE_mg_calloc
#define realloc DO_NOT_USE_THIS_FUNCTION__USE_mg_realloc
#define free DO_NOT_USE_THIS_FUNCTION__USE_mg_free
#define snprintf DO_NOT_USE_THIS_FUNCTION__USE_mg_snprintf
#if defined(_WIN32)
/* vsnprintf must not be used in any system,
 * but this define only works well for Windows. */
#define vsnprintf DO_NOT_USE_THIS_FUNCTION__USE_mg_vsnprintf
#endif
 
 
/* mg_init_library counter */
static int mg_init_library_called = 0;
 
#if !defined(NO_SSL)
#if defined(OPENSSL_API_1_0) || defined(OPENSSL_API_1_1)                       \
    || defined(OPENSSL_API_3_0)
static int mg_openssl_initialized = 0;
#endif
#if !defined(OPENSSL_API_1_0) && !defined(OPENSSL_API_1_1)                     \
    && !defined(OPENSSL_API_3_0) && !defined(USE_MBEDTLS)
#error "Please define OPENSSL_API_1_0 or OPENSSL_API_1_1"
#endif
#if defined(OPENSSL_API_1_0) && defined(OPENSSL_API_1_1)                       \
    && defined(OPENSSL_API_3_0)
#error "Multiple OPENSSL_API versions defined"
#endif
#if (defined(OPENSSL_API_1_0) || defined(OPENSSL_API_1_1)                      \
     || defined(OPENSSL_API_3_0))                                              \
    && defined(USE_MBEDTLS)
#error "Multiple SSL libraries defined"
#endif
#endif
 
 
static pthread_key_t sTlsKey; /* Thread local storage index */
static volatile ptrdiff_t thread_idx_max = 0;
 
#if defined(MG_LEGACY_INTERFACE)
#define MG_ALLOW_USING_GET_REQUEST_INFO_FOR_RESPONSE
#endif
 
struct mg_workerTLS {
   int is_master;
   unsigned long thread_idx;
   void *user_ptr;
#if defined(_WIN32)
   HANDLE pthread_cond_helper_mutex;
   struct mg_workerTLS *next_waiting_thread;
#endif
   const char *alpn_proto;
#if defined(MG_ALLOW_USING_GET_REQUEST_INFO_FOR_RESPONSE)
   char txtbuf[4];
#endif
};
 
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif /* defined(GCC_DIAGNOSTIC) */
#if defined(__clang__)
/* Show no warning in case system functions are not used. */
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
#endif
 
 
/* Get a unique thread ID as unsigned long, independent from the data type
 * of thread IDs defined by the operating system API.
 * If two calls to mg_current_thread_id  return the same value, they calls
 * are done from the same thread. If they return different values, they are
 * done from different threads. (Provided this function is used in the same
 * process context and threads are not repeatedly created and deleted, but
 * CivetWeb does not do that).
 * This function must match the signature required for SSL id callbacks:
 * CRYPTO_set_id_callback
 */
FUNCTION_MAY_BE_UNUSED
static unsigned long
mg_current_thread_id(void)
{
#if defined(_WIN32)
   return GetCurrentThreadId();
#else
 
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
   /* For every compiler, either "sizeof(pthread_t) > sizeof(unsigned long)"
    * or not, so one of the two conditions will be unreachable by construction.
    * Unfortunately the C standard does not define a way to check this at
    * compile time, since the #if preprocessor conditions can not use the
    * sizeof operator as an argument. */
#endif
 
   if (sizeof(pthread_t) > sizeof(unsigned long)) {
      /* This is the problematic case for CRYPTO_set_id_callback:
       * The OS pthread_t can not be cast to unsigned long. */
      struct mg_workerTLS *tls =
          (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
      if (tls == NULL) {
         /* SSL called from an unknown thread: Create some thread index.
          */
         tls = (struct mg_workerTLS *)mg_malloc(sizeof(struct mg_workerTLS));
         tls->is_master = -2; /* -2 means "3rd party thread" */
         tls->thread_idx = (unsigned)mg_atomic_inc(&thread_idx_max);
         pthread_setspecific(sTlsKey, tls);
      }
      return tls->thread_idx;
   } else {
      /* pthread_t may be any data type, so a simple cast to unsigned long
       * can rise a warning/error, depending on the platform.
       * Here memcpy is used as an anything-to-anything cast. */
      unsigned long ret = 0;
      pthread_t t = pthread_self();
      memcpy(&ret, &t, sizeof(pthread_t));
      return ret;
   }
 
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
 
#endif
}
 
 
FUNCTION_MAY_BE_UNUSED
static uint64_t
mg_get_current_time_ns(void)
{
   struct timespec tsnow;
   clock_gettime(CLOCK_REALTIME, &tsnow);
   return (((uint64_t)tsnow.tv_sec) * 1000000000) + (uint64_t)tsnow.tv_nsec;
}
 
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic pop
#endif /* defined(GCC_DIAGNOSTIC) */
#if defined(__clang__)
/* Show no warning in case system functions are not used. */
#pragma clang diagnostic pop
#endif
 
 
#if defined(NEED_DEBUG_TRACE_FUNC)
static void
DEBUG_TRACE_FUNC(const char *func, unsigned line, const char *fmt, ...)
{
   va_list args;
   struct timespec tsnow;
 
   /* Get some operating system independent thread id */
   unsigned long thread_id = mg_current_thread_id();
 
   clock_gettime(CLOCK_REALTIME, &tsnow);
 
   flockfile(DEBUG_TRACE_STREAM);
   fprintf(DEBUG_TRACE_STREAM,
           "*** %lu.%09lu %lu %s:%u: ",
           (unsigned long)tsnow.tv_sec,
           (unsigned long)tsnow.tv_nsec,
           thread_id,
           func,
           line);
   va_start(args, fmt);
   vfprintf(DEBUG_TRACE_STREAM, fmt, args);
   va_end(args);
   putc('\n', DEBUG_TRACE_STREAM);
   fflush(DEBUG_TRACE_STREAM);
   funlockfile(DEBUG_TRACE_STREAM);
}
#endif /* NEED_DEBUG_TRACE_FUNC */
 
 
#define MD5_STATIC static
#include "md5.inl"
 
/* Darwin prior to 7.0 and Win32 do not have socklen_t */
#if defined(NO_SOCKLEN_T)
typedef int socklen_t;
#endif /* NO_SOCKLEN_T */
 
#define IP_ADDR_STR_LEN (50) /* IPv6 hex string is 46 chars */
 
#if !defined(MSG_NOSIGNAL)
#define MSG_NOSIGNAL (0)
#endif
 
 
/* SSL: mbedTLS vs. no-ssl vs. OpenSSL */
#if defined(USE_MBEDTLS)
/* mbedTLS */
#include "mod_mbedtls.inl"
 
#elif defined(NO_SSL)
/* no SSL */
typedef struct SSL SSL; /* dummy for SSL argument to push/pull */
typedef struct SSL_CTX SSL_CTX;
 
#elif defined(NO_SSL_DL)
/* OpenSSL without dynamic loading */
#include <openssl/bn.h>
#include <openssl/conf.h>
#include <openssl/crypto.h>
#include <openssl/dh.h>
#include <openssl/err.h>
#include <openssl/opensslv.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/tls1.h>
#include <openssl/x509.h>
 
#if defined(WOLFSSL_VERSION)
/* Additional defines for WolfSSL, see
 * https://github.com/civetweb/civetweb/issues/583 */
#include "wolfssl_extras.inl"
#endif
 
#if defined(OPENSSL_IS_BORINGSSL)
/* From boringssl/src/include/openssl/mem.h:
 *
 * OpenSSL has, historically, had a complex set of malloc debugging options.
 * However, that was written in a time before Valgrind and ASAN. Since we now
 * have those tools, the OpenSSL allocation functions are simply macros around
 * the standard memory functions.
 *
 * #define OPENSSL_free free */
#define free free
// disable for boringssl
#define CONF_modules_unload(a) ((void)0)
#define ENGINE_cleanup() ((void)0)
#endif
 
/* If OpenSSL headers are included, automatically select the API version */
#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
#if !defined(OPENSSL_API_3_0)
#define OPENSSL_API_3_0
#endif
#define OPENSSL_REMOVE_THREAD_STATE()
#else
#if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
#if !defined(OPENSSL_API_1_1)
#define OPENSSL_API_1_1
#endif
#define OPENSSL_REMOVE_THREAD_STATE()
#else
#if !defined(OPENSSL_API_1_0)
#define OPENSSL_API_1_0
#endif
#define OPENSSL_REMOVE_THREAD_STATE() ERR_remove_thread_state(NULL)
#endif
#endif
 
 
#else
/* SSL loaded dynamically from DLL / shared object */
/* Add all prototypes here, to be independent from OpenSSL source
 * installation. */
#include "openssl_dl.inl"
 
#endif /* Various SSL bindings */
 
 
#if !defined(NO_CACHING)
static const char month_names[][4] = {"Jan",
                                      "Feb",
                                      "Mar",
                                      "Apr",
                                      "May",
                                      "Jun",
                                      "Jul",
                                      "Aug",
                                      "Sep",
                                      "Oct",
                                      "Nov",
                                      "Dec"};
#endif /* !NO_CACHING */
 
 
/* Unified socket address. For IPv6 support, add IPv6 address structure in
 * the union u. */
union usa {
   struct sockaddr sa;
   struct sockaddr_in sin;
#if defined(USE_IPV6)
   struct sockaddr_in6 sin6;
#endif
#if defined(USE_X_DOM_SOCKET)
   struct sockaddr_un sun;
#endif
};
 
#if defined(USE_X_DOM_SOCKET)
static unsigned short
USA_IN_PORT_UNSAFE(union usa *s)
{
   if (s->sa.sa_family == AF_INET)
      return s->sin.sin_port;
#if defined(USE_IPV6)
   if (s->sa.sa_family == AF_INET6)
      return s->sin6.sin6_port;
#endif
   return 0;
}
#endif
#if defined(USE_IPV6)
#define USA_IN_PORT_UNSAFE(s)                                                  \
   (((s)->sa.sa_family == AF_INET6) ? (s)->sin6.sin6_port : (s)->sin.sin_port)
#else
#define USA_IN_PORT_UNSAFE(s) ((s)->sin.sin_port)
#endif
 
/* Describes a string (chunk of memory). */
struct vec {
   const char *ptr;
   size_t len;
};
 
struct mg_file_stat {
   /* File properties filled by mg_stat: */
   uint64_t size;
   time_t last_modified;
   int is_directory; /* Set to 1 if mg_stat is called for a directory */
   int is_gzipped;   /* Set to 1 if the content is gzipped, in which
                      * case we need a "Content-Eencoding: gzip" header */
   int location;     /* 0 = nowhere, 1 = on disk, 2 = in memory */
};
 
 
struct mg_file_access {
   /* File properties filled by mg_fopen: */
   FILE *fp;
};
 
struct mg_file {
   struct mg_file_stat stat;
   struct mg_file_access access;
};
 
 
#define STRUCT_FILE_INITIALIZER                                                \
   {                                                                          \
      {(uint64_t)0, (time_t)0, 0, 0, 0},                                     \
      {                                                                      \
         (FILE *)NULL                                                       \
      }                                                                      \
   }
 
 
/* Describes listening socket, or socket which was accept()-ed by the master
 * thread and queued for future handling by the worker thread. */
struct socket {
   SOCKET sock;             /* Listening socket */
   union usa lsa;           /* Local socket address */
   union usa rsa;           /* Remote socket address */
   unsigned char is_ssl;    /* Is port SSL-ed */
   unsigned char ssl_redir; /* Is port supposed to redirect everything to SSL
                             * port */
   unsigned char in_use;    /* 0: invalid, 1: valid, 2: free */
};
 
 
/* Enum const for all options must be in sync with
 * static struct mg_option config_options[]
 * This is tested in the unit test (test/private.c)
 * "Private Config Options"
 */
enum {
   /* Once for each server */
   LISTENING_PORTS,
   NUM_THREADS,
   RUN_AS_USER,
   CONFIG_TCP_NODELAY, /* Prepended CONFIG_ to avoid conflict with the
                        * socket option typedef TCP_NODELAY. */
   MAX_REQUEST_SIZE,
   LINGER_TIMEOUT,
   CONNECTION_QUEUE_SIZE,
   LISTEN_BACKLOG_SIZE,
#if defined(__linux__)
   ALLOW_SENDFILE_CALL,
#endif
#if defined(_WIN32)
   CASE_SENSITIVE_FILES,
#endif
   THROTTLE,
   ENABLE_KEEP_ALIVE,
   REQUEST_TIMEOUT,
   KEEP_ALIVE_TIMEOUT,
#if defined(USE_WEBSOCKET)
   WEBSOCKET_TIMEOUT,
   ENABLE_WEBSOCKET_PING_PONG,
#endif
   DECODE_URL,
   DECODE_QUERY_STRING,
#if defined(USE_LUA)
   LUA_BACKGROUND_SCRIPT,
   LUA_BACKGROUND_SCRIPT_PARAMS,
#endif
#if defined(USE_HTTP2)
   ENABLE_HTTP2,
#endif
 
   /* Once for each domain */
   DOCUMENT_ROOT,
 
   ACCESS_LOG_FILE,
   ERROR_LOG_FILE,
 
   CGI_EXTENSIONS,
   CGI_ENVIRONMENT,
   CGI_INTERPRETER,
   CGI_INTERPRETER_ARGS,
#if defined(USE_TIMERS)
   CGI_TIMEOUT,
#endif
 
   CGI2_EXTENSIONS,
   CGI2_ENVIRONMENT,
   CGI2_INTERPRETER,
   CGI2_INTERPRETER_ARGS,
#if defined(USE_TIMERS)
   CGI2_TIMEOUT,
#endif
 
#if defined(USE_4_CGI)
   CGI3_EXTENSIONS,
   CGI3_ENVIRONMENT,
   CGI3_INTERPRETER,
   CGI3_INTERPRETER_ARGS,
#if defined(USE_TIMERS)
   CGI3_TIMEOUT,
#endif
 
   CGI4_EXTENSIONS,
   CGI4_ENVIRONMENT,
   CGI4_INTERPRETER,
   CGI4_INTERPRETER_ARGS,
#if defined(USE_TIMERS)
   CGI4_TIMEOUT,
#endif
#endif
 
   PUT_DELETE_PASSWORDS_FILE, /* must follow CGI_* */
   PROTECT_URI,
   AUTHENTICATION_DOMAIN,
   ENABLE_AUTH_DOMAIN_CHECK,
   SSI_EXTENSIONS,
   ENABLE_DIRECTORY_LISTING,
   GLOBAL_PASSWORDS_FILE,
   INDEX_FILES,
   ACCESS_CONTROL_LIST,
   EXTRA_MIME_TYPES,
   SSL_CERTIFICATE,
   SSL_CERTIFICATE_CHAIN,
   URL_REWRITE_PATTERN,
   HIDE_FILES,
   SSL_DO_VERIFY_PEER,
   SSL_CACHE_TIMEOUT,
   SSL_CA_PATH,
   SSL_CA_FILE,
   SSL_VERIFY_DEPTH,
   SSL_DEFAULT_VERIFY_PATHS,
   SSL_CIPHER_LIST,
   SSL_PROTOCOL_VERSION,
   SSL_SHORT_TRUST,
 
#if defined(USE_LUA)
   LUA_PRELOAD_FILE,
   LUA_SCRIPT_EXTENSIONS,
   LUA_SERVER_PAGE_EXTENSIONS,
#if defined(MG_EXPERIMENTAL_INTERFACES)
   LUA_DEBUG_PARAMS,
#endif
#endif
#if defined(USE_DUKTAPE)
   DUKTAPE_SCRIPT_EXTENSIONS,
#endif
 
#if defined(USE_WEBSOCKET)
   WEBSOCKET_ROOT,
#endif
#if defined(USE_LUA) && defined(USE_WEBSOCKET)
   LUA_WEBSOCKET_EXTENSIONS,
#endif
 
   ACCESS_CONTROL_ALLOW_ORIGIN,
   ACCESS_CONTROL_ALLOW_METHODS,
   ACCESS_CONTROL_ALLOW_HEADERS,
   ACCESS_CONTROL_ALLOW_CREDENTIALS,
   ERROR_PAGES,
#if !defined(NO_CACHING)
   STATIC_FILE_MAX_AGE,
   STATIC_FILE_CACHE_CONTROL,
#endif
#if !defined(NO_SSL)
   STRICT_HTTPS_MAX_AGE,
#endif
   ADDITIONAL_HEADER,
   ALLOW_INDEX_SCRIPT_SUB_RES,
 
   NUM_OPTIONS
};
 
 
/* Config option name, config types, default value.
 * Must be in the same order as the enum const above.
 */
static const struct mg_option config_options[] = {
 
    /* Once for each server */
    {"listening_ports", MG_CONFIG_TYPE_STRING_LIST, "8080"},
    {"num_threads", MG_CONFIG_TYPE_NUMBER, "50"},
    {"run_as_user", MG_CONFIG_TYPE_STRING, NULL},
    {"tcp_nodelay", MG_CONFIG_TYPE_NUMBER, "0"},
    {"max_request_size", MG_CONFIG_TYPE_NUMBER, "16384"},
    {"linger_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL},
    {"connection_queue", MG_CONFIG_TYPE_NUMBER, "20"},
    {"listen_backlog", MG_CONFIG_TYPE_NUMBER, "200"},
#if defined(__linux__)
    {"allow_sendfile_call", MG_CONFIG_TYPE_BOOLEAN, "yes"},
#endif
#if defined(_WIN32)
    {"case_sensitive", MG_CONFIG_TYPE_BOOLEAN, "no"},
#endif
    {"throttle", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"enable_keep_alive", MG_CONFIG_TYPE_BOOLEAN, "no"},
    {"request_timeout_ms", MG_CONFIG_TYPE_NUMBER, "30000"},
    {"keep_alive_timeout_ms", MG_CONFIG_TYPE_NUMBER, "500"},
#if defined(USE_WEBSOCKET)
    {"websocket_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL},
    {"enable_websocket_ping_pong", MG_CONFIG_TYPE_BOOLEAN, "no"},
#endif
    {"decode_url", MG_CONFIG_TYPE_BOOLEAN, "yes"},
    {"decode_query_string", MG_CONFIG_TYPE_BOOLEAN, "no"},
#if defined(USE_LUA)
    {"lua_background_script", MG_CONFIG_TYPE_FILE, NULL},
    {"lua_background_script_params", MG_CONFIG_TYPE_STRING_LIST, NULL},
#endif
#if defined(USE_HTTP2)
    {"enable_http2", MG_CONFIG_TYPE_BOOLEAN, "no"},
#endif
 
    /* Once for each domain */
    {"document_root", MG_CONFIG_TYPE_DIRECTORY, NULL},
 
    {"access_log_file", MG_CONFIG_TYPE_FILE, NULL},
    {"error_log_file", MG_CONFIG_TYPE_FILE, NULL},
 
    {"cgi_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.cgi$|**.pl$|**.php$"},
    {"cgi_environment", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"cgi_interpreter", MG_CONFIG_TYPE_FILE, NULL},
    {"cgi_interpreter_args", MG_CONFIG_TYPE_STRING, NULL},
#if defined(USE_TIMERS)
    {"cgi_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL},
#endif
 
    {"cgi2_pattern", MG_CONFIG_TYPE_EXT_PATTERN, NULL},
    {"cgi2_environment", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"cgi2_interpreter", MG_CONFIG_TYPE_FILE, NULL},
    {"cgi2_interpreter_args", MG_CONFIG_TYPE_STRING, NULL},
#if defined(USE_TIMERS)
    {"cgi2_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL},
#endif
 
#if defined(USE_4_CGI)
    {"cgi3_pattern", MG_CONFIG_TYPE_EXT_PATTERN, NULL},
    {"cgi3_environment", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"cgi3_interpreter", MG_CONFIG_TYPE_FILE, NULL},
    {"cgi3_interpreter_args", MG_CONFIG_TYPE_STRING, NULL},
#if defined(USE_TIMERS)
    {"cgi3_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL},
#endif
 
    {"cgi2_pattern", MG_CONFIG_TYPE_EXT_PATTERN, NULL},
    {"cgi4_environment", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"cgi4_interpreter", MG_CONFIG_TYPE_FILE, NULL},
    {"cgi4_interpreter_args", MG_CONFIG_TYPE_STRING, NULL},
#if defined(USE_TIMERS)
    {"cgi4_timeout_ms", MG_CONFIG_TYPE_NUMBER, NULL},
#endif
#endif
 
    {"put_delete_auth_file", MG_CONFIG_TYPE_FILE, NULL},
    {"protect_uri", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"authentication_domain", MG_CONFIG_TYPE_STRING, "mydomain.com"},
    {"enable_auth_domain_check", MG_CONFIG_TYPE_BOOLEAN, "yes"},
    {"ssi_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.shtml$|**.shtm$"},
    {"enable_directory_listing", MG_CONFIG_TYPE_BOOLEAN, "yes"},
    {"global_auth_file", MG_CONFIG_TYPE_FILE, NULL},
    {"index_files",
     MG_CONFIG_TYPE_STRING_LIST,
#if defined(USE_LUA)
     "index.xhtml,index.html,index.htm,"
     "index.lp,index.lsp,index.lua,index.cgi,"
     "index.shtml,index.php"},
#else
     "index.xhtml,index.html,index.htm,index.cgi,index.shtml,index.php"},
#endif
    {"access_control_list", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"extra_mime_types", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"ssl_certificate", MG_CONFIG_TYPE_FILE, NULL},
    {"ssl_certificate_chain", MG_CONFIG_TYPE_FILE, NULL},
    {"url_rewrite_patterns", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"hide_files_patterns", MG_CONFIG_TYPE_EXT_PATTERN, NULL},
 
    {"ssl_verify_peer", MG_CONFIG_TYPE_YES_NO_OPTIONAL, "no"},
    {"ssl_cache_timeout", MG_CONFIG_TYPE_NUMBER, "-1"},
 
    {"ssl_ca_path", MG_CONFIG_TYPE_DIRECTORY, NULL},
    {"ssl_ca_file", MG_CONFIG_TYPE_FILE, NULL},
    {"ssl_verify_depth", MG_CONFIG_TYPE_NUMBER, "9"},
    {"ssl_default_verify_paths", MG_CONFIG_TYPE_BOOLEAN, "yes"},
    {"ssl_cipher_list", MG_CONFIG_TYPE_STRING, NULL},
 
    /* HTTP2 requires ALPN, and anyway TLS1.2 should be considered
     * as a minimum in 2020 */
    {"ssl_protocol_version", MG_CONFIG_TYPE_NUMBER, "4"},
 
    {"ssl_short_trust", MG_CONFIG_TYPE_BOOLEAN, "no"},
 
#if defined(USE_LUA)
    {"lua_preload_file", MG_CONFIG_TYPE_FILE, NULL},
    {"lua_script_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lua$"},
    {"lua_server_page_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lp$|**.lsp$"},
#if defined(MG_EXPERIMENTAL_INTERFACES)
    {"lua_debug", MG_CONFIG_TYPE_STRING, NULL},
#endif
#endif
#if defined(USE_DUKTAPE)
    /* The support for duktape is still in alpha version state.
     * The name of this config option might change. */
    {"duktape_script_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.ssjs$"},
#endif
 
#if defined(USE_WEBSOCKET)
    {"websocket_root", MG_CONFIG_TYPE_DIRECTORY, NULL},
#endif
#if defined(USE_LUA) && defined(USE_WEBSOCKET)
    {"lua_websocket_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lua$"},
#endif
    {"access_control_allow_origin", MG_CONFIG_TYPE_STRING, "*"},
    {"access_control_allow_methods", MG_CONFIG_TYPE_STRING, "*"},
    {"access_control_allow_headers", MG_CONFIG_TYPE_STRING, "*"},
    {"access_control_allow_credentials", MG_CONFIG_TYPE_STRING, ""},
    {"error_pages", MG_CONFIG_TYPE_DIRECTORY, NULL},
#if !defined(NO_CACHING)
    {"static_file_max_age", MG_CONFIG_TYPE_NUMBER, "3600"},
    {"static_file_cache_control", MG_CONFIG_TYPE_STRING, NULL},
#endif
#if !defined(NO_SSL)
    {"strict_transport_security_max_age", MG_CONFIG_TYPE_NUMBER, NULL},
#endif
    {"additional_header", MG_CONFIG_TYPE_STRING_MULTILINE, NULL},
    {"allow_index_script_resource", MG_CONFIG_TYPE_BOOLEAN, "no"},
 
    {NULL, MG_CONFIG_TYPE_UNKNOWN, NULL}};
 
 
/* Check if the config_options and the corresponding enum have compatible
 * sizes. */
mg_static_assert((sizeof(config_options) / sizeof(config_options[0]))
                     == (NUM_OPTIONS + 1),
                 "config_options and enum not sync");
 
 
enum { REQUEST_HANDLER, WEBSOCKET_HANDLER, AUTH_HANDLER };
 
 
struct mg_handler_info {
   /* Name/Pattern of the URI. */
   char *uri;
   size_t uri_len;
 
   /* handler type */
   int handler_type;
 
   /* Handler for http/https or authorization requests. */
   mg_request_handler handler;
   unsigned int refcount;
   int removing;
 
   /* Handler for ws/wss (websocket) requests. */
   mg_websocket_connect_handler connect_handler;
   mg_websocket_ready_handler ready_handler;
   mg_websocket_data_handler data_handler;
   mg_websocket_close_handler close_handler;
 
   /* accepted subprotocols for ws/wss requests. */
   struct mg_websocket_subprotocols *subprotocols;
 
   /* Handler for authorization requests */
   mg_authorization_handler auth_handler;
 
   /* User supplied argument for the handler function. */
   void *cbdata;
 
   /* next handler in a linked list */
   struct mg_handler_info *next;
};
 
 
enum {
   CONTEXT_INVALID,
   CONTEXT_SERVER,
   CONTEXT_HTTP_CLIENT,
   CONTEXT_WS_CLIENT
};
 
 
struct mg_domain_context {
   SSL_CTX *ssl_ctx;                 /* SSL context */
   char *config[NUM_OPTIONS];        /* Civetweb configuration parameters */
   struct mg_handler_info *handlers; /* linked list of uri handlers */
   int64_t ssl_cert_last_mtime;
 
   /* Server nonce */
   uint64_t auth_nonce_mask;  /* Mask for all nonce values */
   unsigned long nonce_count; /* Used nonces, used for authentication */
 
#if defined(USE_LUA) && defined(USE_WEBSOCKET)
   /* linked list of shared lua websockets */
   struct mg_shared_lua_websocket_list *shared_lua_websockets;
#endif
 
   /* Linked list of domains */
   struct mg_domain_context *next;
};
 
 
/* Stop flag can be "volatile" or require a lock.
 * MSDN uses volatile for "Interlocked" operations, but also explicitly
 * states a read operation for int is always atomic. */
#if defined(STOP_FLAG_NEEDS_LOCK)
 
typedef ptrdiff_t volatile stop_flag_t;
 
static int
STOP_FLAG_IS_ZERO(stop_flag_t *f)
{
   stop_flag_t sf = mg_atomic_add(f, 0);
   return (sf == 0);
}
 
static int
STOP_FLAG_IS_TWO(stop_flag_t *f)
{
   stop_flag_t sf = mg_atomic_add(f, 0);
   return (sf == 2);
}
 
static void
STOP_FLAG_ASSIGN(stop_flag_t *f, stop_flag_t v)
{
   stop_flag_t sf;
   do {
      sf = mg_atomic_compare_and_swap(f, *f, v);
   } while (sf != v);
}
 
#else /* STOP_FLAG_NEEDS_LOCK */
 
typedef int volatile stop_flag_t;
#define STOP_FLAG_IS_ZERO(f) ((*(f)) == 0)
#define STOP_FLAG_IS_TWO(f) ((*(f)) == 2)
#define STOP_FLAG_ASSIGN(f, v) ((*(f)) = (v))
 
#endif /* STOP_FLAG_NEEDS_LOCK */
 
 
struct mg_context {
 
   /* Part 1 - Physical context:
    * This holds threads, ports, timeouts, ...
    * set for the entire server, independent from the
    * addressed hostname.
    */
 
   /* Connection related */
   int context_type; /* See CONTEXT_* above */
 
   struct socket *listening_sockets;
   struct mg_pollfd *listening_socket_fds;
   unsigned int num_listening_sockets;
 
   struct mg_connection *worker_connections; /* The connection struct, pre-
                                              * allocated for each worker */
 
#if defined(USE_SERVER_STATS)
   volatile ptrdiff_t active_connections;
   volatile ptrdiff_t max_active_connections;
   volatile ptrdiff_t total_connections;
   volatile ptrdiff_t total_requests;
   volatile int64_t total_data_read;
   volatile int64_t total_data_written;
#endif
 
   /* Thread related */
   stop_flag_t stop_flag;        /* Should we stop event loop */
   pthread_mutex_t thread_mutex; /* Protects client_socks or queue */
 
   pthread_t masterthreadid; /* The master thread ID */
   unsigned int
       cfg_worker_threads;      /* The number of configured worker threads. */
   pthread_t *worker_threadids; /* The worker thread IDs */
   unsigned long starter_thread_idx; /* thread index which called mg_start */
 
   /* Connection to thread dispatching */
#if defined(ALTERNATIVE_QUEUE)
   struct socket *client_socks;
   void **client_wait_events;
#else
   struct socket *squeue; /* Socket queue (sq) : accepted sockets waiting for a
                          worker thread */
   volatile int sq_head;  /* Head of the socket queue */
   volatile int sq_tail;  /* Tail of the socket queue */
   pthread_cond_t sq_full;  /* Signaled when socket is produced */
   pthread_cond_t sq_empty; /* Signaled when socket is consumed */
   volatile int sq_blocked; /* Status information: sq is full */
   int sq_size;             /* No of elements in socket queue */
#if defined(USE_SERVER_STATS)
   int sq_max_fill;
#endif /* USE_SERVER_STATS */
#endif /* ALTERNATIVE_QUEUE */
 
   /* Memory related */
   unsigned int max_request_size; /* The max request size */
 
#if defined(USE_SERVER_STATS)
   struct mg_memory_stat ctx_memory;
#endif
 
   /* Operating system related */
   char *systemName;  /* What operating system is running */
   time_t start_time; /* Server start time, used for authentication
                       * and for diagnstics. */
 
#if defined(USE_TIMERS)
   struct ttimers *timers;
#endif
 
   /* Lua specific: Background operations and shared websockets */
#if defined(USE_LUA)
   void *lua_background_state;   /* lua_State (here as void *) */
   pthread_mutex_t lua_bg_mutex; /* Protect background state */
   int lua_bg_log_available;     /* Use Lua background state for access log */
#endif
 
   /* Server nonce */
   pthread_mutex_t nonce_mutex; /* Protects ssl_ctx, handlers,
                                 * ssl_cert_last_mtime, nonce_count, and
                                 * next (linked list) */
 
   /* Server callbacks */
   struct mg_callbacks callbacks; /* User-defined callback function */
   void *user_data;               /* User-defined data */
 
   /* Part 2 - Logical domain:
    * This holds hostname, TLS certificate, document root, ...
    * set for a domain hosted at the server.
    * There may be multiple domains hosted at one physical server.
    * The default domain "dd" is the first element of a list of
    * domains.
    */
   struct mg_domain_context dd; /* default domain */
};
 
 
#if defined(USE_SERVER_STATS)
static struct mg_memory_stat mg_common_memory = {0, 0, 0};
 
static struct mg_memory_stat *
get_memory_stat(struct mg_context *ctx)
{
   if (ctx) {
      return &(ctx->ctx_memory);
   }
   return &mg_common_memory;
}
#endif
 
enum {
   CONNECTION_TYPE_INVALID = 0,
   CONNECTION_TYPE_REQUEST = 1,
   CONNECTION_TYPE_RESPONSE = 2
};
 
enum {
   PROTOCOL_TYPE_HTTP1 = 0,
   PROTOCOL_TYPE_WEBSOCKET = 1,
   PROTOCOL_TYPE_HTTP2 = 2
};
 
 
#if defined(USE_HTTP2)
#if !defined(HTTP2_DYN_TABLE_SIZE)
#define HTTP2_DYN_TABLE_SIZE (256)
#endif
 
struct mg_http2_connection {
   uint32_t stream_id;
   uint32_t dyn_table_size;
   struct mg_header dyn_table[HTTP2_DYN_TABLE_SIZE];
};
#endif
 
 
struct mg_connection {
   int connection_type; /* see CONNECTION_TYPE_* above */
   int protocol_type;   /* see PROTOCOL_TYPE_*: 0=http/1.x, 1=ws, 2=http/2 */
   int request_state;   /* 0: nothing sent, 1: header partially sent, 2: header
                        fully sent */
#if defined(USE_HTTP2)
   struct mg_http2_connection http2;
#endif
 
   struct mg_request_info request_info;
   struct mg_response_info response_info;
 
   struct mg_context *phys_ctx;
   struct mg_domain_context *dom_ctx;
 
#if defined(USE_SERVER_STATS)
   int conn_state; /* 0 = undef, numerical value may change in different
                    * versions. For the current definition, see
                    * mg_get_connection_info_impl */
#endif
 
   SSL *ssl;               /* SSL descriptor */
   struct socket client;   /* Connected client */
   time_t conn_birth_time; /* Time (wall clock) when connection was
                            * established */
#if defined(USE_SERVER_STATS)
   time_t conn_close_time; /* Time (wall clock) when connection was
                            * closed (or 0 if still open) */
   double processing_time; /* Procesing time for one request. */
#endif
   struct timespec req_time; /* Time (since system start) when the request
                              * was received */
   int64_t num_bytes_sent;   /* Total bytes sent to client */
   int64_t content_len;      /* How many bytes of content can be read
                              * !is_chunked: Content-Length header value
                              *              or -1 (until connection closed,
                              *                     not allowed for a request)
                              * is_chunked: >= 0, appended gradually
                              */
   int64_t consumed_content; /* How many bytes of content have been read */
   int is_chunked;           /* Transfer-Encoding is chunked:
                              * 0 = not chunked,
                              * 1 = chunked, not yet, or some data read,
                              * 2 = chunked, has error,
                              * 3 = chunked, all data read except trailer,
                              * 4 = chunked, all data read
                              */
   char *buf;                /* Buffer for received data */
   char *path_info;          /* PATH_INFO part of the URL */
 
   int must_close;       /* 1 if connection must be closed */
   int accept_gzip;      /* 1 if gzip encoding is accepted */
   int in_error_handler; /* 1 if in handler for user defined error
                          * pages */
#if defined(USE_WEBSOCKET)
   int in_websocket_handling; /* 1 if in read_websocket */
#endif
#if defined(USE_ZLIB) && defined(USE_WEBSOCKET)                                \
    && defined(MG_EXPERIMENTAL_INTERFACES)
   /* Parameters for websocket data compression according to rfc7692 */
   int websocket_deflate_server_max_windows_bits;
   int websocket_deflate_client_max_windows_bits;
   int websocket_deflate_server_no_context_takeover;
   int websocket_deflate_client_no_context_takeover;
   int websocket_deflate_initialized;
   int websocket_deflate_flush;
   z_stream websocket_deflate_state;
   z_stream websocket_inflate_state;
#endif
   int handled_requests; /* Number of requests handled by this connection
                          */
   int buf_size;         /* Buffer size */
   int request_len;      /* Size of the request + headers in a buffer */
   int data_len;         /* Total size of data in a buffer */
   int status_code;      /* HTTP reply status code, e.g. 200 */
   int throttle;         /* Throttling, bytes/sec. <= 0 means no
                          * throttle */
 
   time_t last_throttle_time; /* Last time throttled data was sent */
   int last_throttle_bytes;   /* Bytes sent this second */
   pthread_mutex_t mutex;     /* Used by mg_(un)lock_connection to ensure
                               * atomic transmissions for websockets */
#if defined(USE_LUA) && defined(USE_WEBSOCKET)
   void *lua_websocket_state; /* Lua_State for a websocket connection */
#endif
 
   void *tls_user_ptr; /* User defined pointer in thread local storage,
                        * for quick access */
};
 
 
/* Directory entry */
struct de {
   struct mg_connection *conn;
   char *file_name;
   struct mg_file_stat file;
};
 
 
#define mg_cry_internal(conn, fmt, ...)                                        \
   mg_cry_internal_wrap(conn, NULL, __func__, __LINE__, fmt, __VA_ARGS__)
 
#define mg_cry_ctx_internal(ctx, fmt, ...)                                     \
   mg_cry_internal_wrap(NULL, ctx, __func__, __LINE__, fmt, __VA_ARGS__)
 
static void mg_cry_internal_wrap(const struct mg_connection *conn,
                                 struct mg_context *ctx,
                                 const char *func,
                                 unsigned line,
                                 const char *fmt,
                                 ...) PRINTF_ARGS(5, 6);
 
 
#if !defined(NO_THREAD_NAME)
#if defined(_WIN32) && defined(_MSC_VER)
/* Set the thread name for debugging purposes in Visual Studio
 * http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
 */
#pragma pack(push, 8)
typedef struct tagTHREADNAME_INFO {
   DWORD dwType;     /* Must be 0x1000. */
   LPCSTR szName;    /* Pointer to name (in user addr space). */
   DWORD dwThreadID; /* Thread ID (-1=caller thread). */
   DWORD dwFlags;    /* Reserved for future use, must be zero. */
} THREADNAME_INFO;
#pragma pack(pop)
 
#elif defined(__linux__)
 
#include <sys/prctl.h>
#include <sys/sendfile.h>
#if defined(ALTERNATIVE_QUEUE)
#include <sys/eventfd.h>
#endif /* ALTERNATIVE_QUEUE */
 
 
#if defined(ALTERNATIVE_QUEUE)
 
static void *
event_create(void)
{
   int evhdl = eventfd(0, EFD_CLOEXEC);
   int *ret;
 
   if (evhdl == -1) {
      /* Linux uses -1 on error, Windows NULL. */
      /* However, Linux does not return 0 on success either. */
      return 0;
   }
 
   ret = (int *)mg_malloc(sizeof(int));
   if (ret) {
      *ret = evhdl;
   } else {
      (void)close(evhdl);
   }
 
   return (void *)ret;
}
 
 
static int
event_wait(void *eventhdl)
{
   uint64_t u;
   int evhdl, s;
 
   if (!eventhdl) {
      /* error */
      return 0;
   }
   evhdl = *(int *)eventhdl;
 
   s = (int)read(evhdl, &u, sizeof(u));
   if (s != sizeof(u)) {
      /* error */
      return 0;
   }
   (void)u; /* the value is not required */
   return 1;
}
 
 
static int
event_signal(void *eventhdl)
{
   uint64_t u = 1;
   int evhdl, s;
 
   if (!eventhdl) {
      /* error */
      return 0;
   }
   evhdl = *(int *)eventhdl;
 
   s = (int)write(evhdl, &u, sizeof(u));
   if (s != sizeof(u)) {
      /* error */
      return 0;
   }
   return 1;
}
 
 
static void
event_destroy(void *eventhdl)
{
   int evhdl;
 
   if (!eventhdl) {
      /* error */
      return;
   }
   evhdl = *(int *)eventhdl;
 
   close(evhdl);
   mg_free(eventhdl);
}
 
 
#endif
 
#endif
 
 
#if !defined(__linux__) && !defined(_WIN32) && defined(ALTERNATIVE_QUEUE)
 
struct posix_event {
   pthread_mutex_t mutex;
   pthread_cond_t cond;
   int signaled;
};
 
 
static void *
event_create(void)
{
   struct posix_event *ret = mg_malloc(sizeof(struct posix_event));
   if (ret == 0) {
      /* out of memory */
      return 0;
   }
   if (0 != pthread_mutex_init(&(ret->mutex), NULL)) {
      /* pthread mutex not available */
      mg_free(ret);
      return 0;
   }
   if (0 != pthread_cond_init(&(ret->cond), NULL)) {
      /* pthread cond not available */
      pthread_mutex_destroy(&(ret->mutex));
      mg_free(ret);
      return 0;
   }
   ret->signaled = 0;
   return (void *)ret;
}
 
 
static int
event_wait(void *eventhdl)
{
   struct posix_event *ev = (struct posix_event *)eventhdl;
   pthread_mutex_lock(&(ev->mutex));
   while (!ev->signaled) {
      pthread_cond_wait(&(ev->cond), &(ev->mutex));
   }
   ev->signaled = 0;
   pthread_mutex_unlock(&(ev->mutex));
   return 1;
}
 
 
static int
event_signal(void *eventhdl)
{
   struct posix_event *ev = (struct posix_event *)eventhdl;
   pthread_mutex_lock(&(ev->mutex));
   pthread_cond_signal(&(ev->cond));
   ev->signaled = 1;
   pthread_mutex_unlock(&(ev->mutex));
   return 1;
}
 
 
static void
event_destroy(void *eventhdl)
{
   struct posix_event *ev = (struct posix_event *)eventhdl;
   pthread_cond_destroy(&(ev->cond));
   pthread_mutex_destroy(&(ev->mutex));
   mg_free(ev);
}
#endif
 
 
static void
mg_set_thread_name(const char *name)
{
   char threadName[16 + 1]; /* 16 = Max. thread length in Linux/OSX/.. */
 
   mg_snprintf(
       NULL, NULL, threadName, sizeof(threadName), "civetweb-%s", name);
 
#if defined(_WIN32)
#if defined(_MSC_VER)
   /* Windows and Visual Studio Compiler */
   __try {
      THREADNAME_INFO info;
      info.dwType = 0x1000;
      info.szName = threadName;
      info.dwThreadID = ~0U;
      info.dwFlags = 0;
 
      RaiseException(0x406D1388,
                     0,
                     sizeof(info) / sizeof(ULONG_PTR),
                     (ULONG_PTR *)&info);
   } __except (EXCEPTION_EXECUTE_HANDLER) {
   }
#elif defined(__MINGW32__)
   /* No option known to set thread name for MinGW known */
#endif
#elif defined(_GNU_SOURCE) && defined(__GLIBC__)                               \
    && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 12)))
   /* pthread_setname_np first appeared in glibc in version 2.12 */
#if defined(__MACH__)
   /* OS X only current thread name can be changed */
   (void)pthread_setname_np(threadName);
#else
   (void)pthread_setname_np(pthread_self(), threadName);
#endif
#elif defined(__linux__)
   /* On Linux we can use the prctl function.
    * When building for Linux Standard Base (LSB) use
    * NO_THREAD_NAME. However, thread names are a big
    * help for debugging, so the stadard is to set them.
    */
   (void)prctl(PR_SET_NAME, threadName, 0, 0, 0);
#endif
}
#else /* !defined(NO_THREAD_NAME) */
void
mg_set_thread_name(const char *threadName)
{
}
#endif
 
 
const struct mg_option *
mg_get_valid_options(void)
{
   return config_options;
}
 
 
/* Do not open file (unused) */
#define MG_FOPEN_MODE_NONE (0)
 
/* Open file for read only access */
#define MG_FOPEN_MODE_READ (1)
 
/* Open file for writing, create and overwrite */
#define MG_FOPEN_MODE_WRITE (2)
 
/* Open file for writing, create and append */
#define MG_FOPEN_MODE_APPEND (4)
 
 
static int
is_file_opened(const struct mg_file_access *fileacc)
{
   if (!fileacc) {
      return 0;
   }
 
   return (fileacc->fp != NULL);
}
 
 
#if !defined(NO_FILESYSTEMS)
static int mg_stat(const struct mg_connection *conn,
                   const char *path,
                   struct mg_file_stat *filep);
 
 
/* Reject files with special characters (for Windows) */
static int
mg_path_suspicious(const struct mg_connection *conn, const char *path)
{
   const uint8_t *c = (const uint8_t *)path;
   (void)conn; /* not used */
 
   if ((c == NULL) || (c[0] == 0)) {
      /* Null pointer or empty path --> suspicious */
      return 1;
   }
 
#if defined(_WIN32)
   while (*c) {
      if (*c < 32) {
         /* Control character */
         return 1;
      }
      if ((*c == '>') || (*c == '<') || (*c == '|')) {
         /* stdin/stdout redirection character */
         return 1;
      }
      if ((*c == '*') || (*c == '?')) {
         /* Wildcard character */
         return 1;
      }
      if (*c == '"') {
         /* Windows quotation */
         return 1;
      }
      c++;
   }
#endif
 
   /* Nothing suspicious found */
   return 0;
}
 
 
/* mg_fopen will open a file either in memory or on the disk.
 * The input parameter path is a string in UTF-8 encoding.
 * The input parameter mode is MG_FOPEN_MODE_*
 * On success, fp will be set in the output struct mg_file.
 * All status members will also be set.
 * The function returns 1 on success, 0 on error. */
static int
mg_fopen(const struct mg_connection *conn,
         const char *path,
         int mode,
         struct mg_file *filep)
{
   int found;
 
   if (!filep) {
      return 0;
   }
   filep->access.fp = NULL;
 
   if (mg_path_suspicious(conn, path)) {
      return 0;
   }
 
   /* filep is initialized in mg_stat: all fields with memset to,
    * some fields like size and modification date with values */
   found = mg_stat(conn, path, &(filep->stat));
 
   if ((mode == MG_FOPEN_MODE_READ) && (!found)) {
      /* file does not exist and will not be created */
      return 0;
   }
 
#if defined(_WIN32)
   {
      wchar_t wbuf[UTF16_PATH_MAX];
      path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf));
      switch (mode) {
      case MG_FOPEN_MODE_READ:
         filep->access.fp = _wfopen(wbuf, L"rb");
         break;
      case MG_FOPEN_MODE_WRITE:
         filep->access.fp = _wfopen(wbuf, L"wb");
         break;
      case MG_FOPEN_MODE_APPEND:
         filep->access.fp = _wfopen(wbuf, L"ab");
         break;
      }
   }
#else
   /* Linux et al already use unicode. No need to convert. */
   switch (mode) {
   case MG_FOPEN_MODE_READ:
      filep->access.fp = fopen(path, "r");
      break;
   case MG_FOPEN_MODE_WRITE:
      filep->access.fp = fopen(path, "w");
      break;
   case MG_FOPEN_MODE_APPEND:
      filep->access.fp = fopen(path, "a");
      break;
   }
 
#endif
   if (!found) {
      /* File did not exist before fopen was called.
       * Maybe it has been created now. Get stat info
       * like creation time now. */
      found = mg_stat(conn, path, &(filep->stat));
      (void)found;
   }
 
   /* return OK if file is opened */
   return (filep->access.fp != NULL);
}
 
 
/* return 0 on success, just like fclose */
static int
mg_fclose(struct mg_file_access *fileacc)
{
   int ret = -1;
   if (fileacc != NULL) {
      if (fileacc->fp != NULL) {
         ret = fclose(fileacc->fp);
      }
      /* reset all members of fileacc */
      memset(fileacc, 0, sizeof(*fileacc));
   }
   return ret;
}
#endif /* NO_FILESYSTEMS */
 
 
static void
mg_strlcpy(char *dst, const char *src, size_t n)
{
   for (; *src != '\0' && n > 1; n--) {
      *dst++ = *src++;
   }
   *dst = '\0';
}
 
 
static int
lowercase(const char *s)
{
   return tolower((unsigned char)*s);
}
 
 
int
mg_strncasecmp(const char *s1, const char *s2, size_t len)
{
   int diff = 0;
 
   if (len > 0) {
      do {
         diff = lowercase(s1++) - lowercase(s2++);
      } while (diff == 0 && s1[-1] != '\0' && --len > 0);
   }
 
   return diff;
}
 
 
int
mg_strcasecmp(const char *s1, const char *s2)
{
   int diff;
 
   do {
      diff = lowercase(s1++) - lowercase(s2++);
   } while (diff == 0 && s1[-1] != '\0');
 
   return diff;
}
 
 
static char *
mg_strndup_ctx(const char *ptr, size_t len, struct mg_context *ctx)
{
   char *p;
   (void)ctx; /* Avoid Visual Studio warning if USE_SERVER_STATS is not
               * defined */
 
   if ((p = (char *)mg_malloc_ctx(len + 1, ctx)) != NULL) {
      mg_strlcpy(p, ptr, len + 1);
   }
 
   return p;
}
 
 
static char *
mg_strdup_ctx(const char *str, struct mg_context *ctx)
{
   return mg_strndup_ctx(str, strlen(str), ctx);
}
 
static char *
mg_strdup(const char *str)
{
   return mg_strndup_ctx(str, strlen(str), NULL);
}
 
 
static const char *
mg_strcasestr(const char *big_str, const char *small_str)
{
   size_t i, big_len = strlen(big_str), small_len = strlen(small_str);
 
   if (big_len >= small_len) {
      for (i = 0; i <= (big_len - small_len); i++) {
         if (mg_strncasecmp(big_str + i, small_str, small_len) == 0) {
            return big_str + i;
         }
      }
   }
 
   return NULL;
}
 
 
/* Return null terminated string of given maximum length.
 * Report errors if length is exceeded. */
static void
mg_vsnprintf(const struct mg_connection *conn,
             int *truncated,
             char *buf,
             size_t buflen,
             const char *fmt,
             va_list ap)
{
   int n, ok;
 
   if (buflen == 0) {
      if (truncated) {
         *truncated = 1;
      }
      return;
   }
 
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
   /* Using fmt as a non-literal is intended here, since it is mostly called
    * indirectly by mg_snprintf */
#endif
 
   n = (int)vsnprintf_impl(buf, buflen, fmt, ap);
   ok = (n >= 0) && ((size_t)n < buflen);
 
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
 
   if (ok) {
      if (truncated) {
         *truncated = 0;
      }
   } else {
      if (truncated) {
         *truncated = 1;
      }
      mg_cry_internal(conn,
                      "truncating vsnprintf buffer: [%.*s]",
                      (int)((buflen > 200) ? 200 : (buflen - 1)),
                      buf);
      n = (int)buflen - 1;
   }
   buf[n] = '\0';
}
 
 
static void
mg_snprintf(const struct mg_connection *conn,
            int *truncated,
            char *buf,
            size_t buflen,
            const char *fmt,
            ...)
{
   va_list ap;
 
   va_start(ap, fmt);
   mg_vsnprintf(conn, truncated, buf, buflen, fmt, ap);
   va_end(ap);
}
 
 
static int
get_option_index(const char *name)
{
   int i;
 
   for (i = 0; config_options[i].name != NULL; i++) {
      if (strcmp(config_options[i].name, name) == 0) {
         return i;
      }
   }
   return -1;
}
 
 
const char *
mg_get_option(const struct mg_context *ctx, const char *name)
{
   int i;
   if ((i = get_option_index(name)) == -1) {
      return NULL;
   } else if (!ctx || ctx->dd.config[i] == NULL) {
      return "";
   } else {
      return ctx->dd.config[i];
   }
}
 
#define mg_get_option DO_NOT_USE_THIS_FUNCTION_INTERNALLY__access_directly
 
struct mg_context *
mg_get_context(const struct mg_connection *conn)
{
   return (conn == NULL) ? (struct mg_context *)NULL : (conn->phys_ctx);
}
 
 
void *
mg_get_user_data(const struct mg_context *ctx)
{
   return (ctx == NULL) ? NULL : ctx->user_data;
}
 
 
void *
mg_get_user_context_data(const struct mg_connection *conn)
{
   return mg_get_user_data(mg_get_context(conn));
}
 
 
void *
mg_get_thread_pointer(const struct mg_connection *conn)
{
   /* both methods should return the same pointer */
   if (conn) {
      /* quick access, in case conn is known */
      return conn->tls_user_ptr;
   } else {
      /* otherwise get pointer from thread local storage (TLS) */
      struct mg_workerTLS *tls =
          (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
      return tls->user_ptr;
   }
}
 
 
void
mg_set_user_connection_data(const struct mg_connection *const_conn, void *data)
{
   if (const_conn != NULL) {
      /* Const cast, since "const struct mg_connection *" does not mean
       * the connection object is not modified. Here "const" is used,
       * to indicate mg_read/mg_write/mg_send/.. must not be called. */
      struct mg_connection *conn = (struct mg_connection *)const_conn;
      conn->request_info.conn_data = data;
   }
}
 
 
void *
mg_get_user_connection_data(const struct mg_connection *conn)
{
   if (conn != NULL) {
      return conn->request_info.conn_data;
   }
   return NULL;
}
 
 
int
mg_get_server_ports(const struct mg_context *ctx,
                    int size,
                    struct mg_server_port *ports)
{
   int i, cnt = 0;
 
   if (size <= 0) {
      return -1;
   }
   memset(ports, 0, sizeof(*ports) * (size_t)size);
   if (!ctx) {
      return -1;
   }
   if (!ctx->listening_sockets) {
      return -1;
   }
 
   for (i = 0; (i < size) && (i < (int)ctx->num_listening_sockets); i++) {
 
      ports[cnt].port =
          ntohs(USA_IN_PORT_UNSAFE(&(ctx->listening_sockets[i].lsa)));
      ports[cnt].is_ssl = ctx->listening_sockets[i].is_ssl;
      ports[cnt].is_redirect = ctx->listening_sockets[i].ssl_redir;
 
      if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET) {
         /* IPv4 */
         ports[cnt].protocol = 1;
         cnt++;
      } else if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6) {
         /* IPv6 */
         ports[cnt].protocol = 3;
         cnt++;
      }
   }
 
   return cnt;
}
 
 
#if defined(USE_X_DOM_SOCKET) && !defined(UNIX_DOMAIN_SOCKET_SERVER_NAME)
#define UNIX_DOMAIN_SOCKET_SERVER_NAME "*"
#endif
 
static void
sockaddr_to_string(char *buf, size_t len, const union usa *usa)
{
   buf[0] = '\0';
 
   if (!usa) {
      return;
   }
 
   if (usa->sa.sa_family == AF_INET) {
      getnameinfo(&usa->sa,
                  sizeof(usa->sin),
                  buf,
                  (unsigned)len,
                  NULL,
                  0,
                  NI_NUMERICHOST);
   }
#if defined(USE_IPV6)
   else if (usa->sa.sa_family == AF_INET6) {
      getnameinfo(&usa->sa,
                  sizeof(usa->sin6),
                  buf,
                  (unsigned)len,
                  NULL,
                  0,
                  NI_NUMERICHOST);
   }
#endif
#if defined(USE_X_DOM_SOCKET)
   else if (usa->sa.sa_family == AF_UNIX) {
      /* TODO: Define a remote address for unix domain sockets.
      * This code will always return "localhost", identical to http+tcp:
      getnameinfo(&usa->sa,
      sizeof(usa->sun),
      buf,
      (unsigned)len,
      NULL,
      0,
      NI_NUMERICHOST);
      */
      strncpy(buf, UNIX_DOMAIN_SOCKET_SERVER_NAME, len);
      buf[len-1] = 0;
   }
#endif
}
 
 
/* Convert time_t to a string. According to RFC2616, Sec 14.18, this must be
 * included in all responses other than 100, 101, 5xx. */
static void
gmt_time_string(char *buf, size_t buf_len, time_t *t)
{
#if !defined(REENTRANT_TIME)
   struct tm *tm;
 
   tm = ((t != NULL) ? gmtime(t) : NULL);
   if (tm != NULL) {
#else
   struct tm _tm;
   struct tm *tm = &_tm;
 
   if (t != NULL) {
      gmtime_r(t, tm);
#endif
      strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", tm);
   } else {
      mg_strlcpy(buf, "Thu, 01 Jan 1970 00:00:00 GMT", buf_len);
      buf[buf_len - 1] = '\0';
   }
}
 
 
/* difftime for struct timespec. Return value is in seconds. */
static double
mg_difftimespec(const struct timespec *ts_now, const struct timespec *ts_before)
{
   return (double)(ts_now->tv_nsec - ts_before->tv_nsec) * 1.0E-9
          + (double)(ts_now->tv_sec - ts_before->tv_sec);
}
 
 
#if defined(MG_EXTERNAL_FUNCTION_mg_cry_internal_impl)
static void mg_cry_internal_impl(const struct mg_connection *conn,
                                 const char *func,
                                 unsigned line,
                                 const char *fmt,
                                 va_list ap);
#include "external_mg_cry_internal_impl.inl"
#elif !defined(NO_FILESYSTEMS)
 
/* Print error message to the opened error log stream. */
static void
mg_cry_internal_impl(const struct mg_connection *conn,
                     const char *func,
                     unsigned line,
                     const char *fmt,
                     va_list ap)
{
   char buf[MG_BUF_LEN], src_addr[IP_ADDR_STR_LEN];
   struct mg_file fi;
   time_t timestamp;
 
   /* Unused, in the RELEASE build */
   (void)func;
   (void)line;
 
#if defined(GCC_DIAGNOSTIC)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif
 
   IGNORE_UNUSED_RESULT(vsnprintf_impl(buf, sizeof(buf), fmt, ap));
 
#if defined(GCC_DIAGNOSTIC)
#pragma GCC diagnostic pop
#endif
 
   buf[sizeof(buf) - 1] = 0;
 
   DEBUG_TRACE("mg_cry called from %s:%u: %s", func, line, buf);
 
   if (!conn) {
      puts(buf);
      return;
   }
 
   /* Do not lock when getting the callback value, here and below.
    * I suppose this is fine, since function cannot disappear in the
    * same way string option can. */
   if ((conn->phys_ctx->callbacks.log_message == NULL)
       || (conn->phys_ctx->callbacks.log_message(conn, buf) == 0)) {
 
      if (conn->dom_ctx->config[ERROR_LOG_FILE] != NULL) {
         if (mg_fopen(conn,
                      conn->dom_ctx->config[ERROR_LOG_FILE],
                      MG_FOPEN_MODE_APPEND,
                      &fi)
             == 0) {
            fi.access.fp = NULL;
         }
      } else {
         fi.access.fp = NULL;
      }
 
      if (fi.access.fp != NULL) {
         flockfile(fi.access.fp);
         timestamp = time(NULL);
 
         sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
         fprintf(fi.access.fp,
                 "[%010lu] [error] [client %s] ",
                 (unsigned long)timestamp,
                 src_addr);
 
         if (conn->request_info.request_method != NULL) {
            fprintf(fi.access.fp,
                    "%s %s: ",
                    conn->request_info.request_method,
                    conn->request_info.request_uri
                        ? conn->request_info.request_uri
                        : "");
         }
 
         fprintf(fi.access.fp, "%s", buf);
         fputc('\n', fi.access.fp);
         fflush(fi.access.fp);
         funlockfile(fi.access.fp);
         (void)mg_fclose(&fi.access); /* Ignore errors. We can't call
                                       * mg_cry here anyway ;-) */
      }
   }
}
#else
#error Must either enable filesystems or provide a custom mg_cry_internal_impl implementation
#endif /* Externally provided function */
 
 
/* Construct fake connection structure. Used for logging, if connection
 * is not applicable at the moment of logging. */
static struct mg_connection *
fake_connection(struct mg_connection *fc, struct mg_context *ctx)
{
   static const struct mg_connection conn_zero = {0};
   *fc = conn_zero;
   fc->phys_ctx = ctx;
   fc->dom_ctx = &(ctx->dd);
   return fc;
}
 
 
static void
mg_cry_internal_wrap(const struct mg_connection *conn,
                     struct mg_context *ctx,
                     const char *func,
                     unsigned line,
                     const char *fmt,
                     ...)
{
   va_list ap;
   va_start(ap, fmt);
   if (!conn && ctx) {
      struct mg_connection fc;
      mg_cry_internal_impl(fake_connection(&fc, ctx), func, line, fmt, ap);
   } else {
      mg_cry_internal_impl(conn, func, line, fmt, ap);
   }
   va_end(ap);
}
 
 
void
mg_cry(const struct mg_connection *conn, const char *fmt, ...)
{
   va_list ap;
   va_start(ap, fmt);
   mg_cry_internal_impl(conn, "user", 0, fmt, ap);
   va_end(ap);
}
 
 
#define mg_cry DO_NOT_USE_THIS_FUNCTION__USE_mg_cry_internal
 
 
const char *
mg_version(void)
{
   return CIVETWEB_VERSION;
}
 
 
const struct mg_request_info *
mg_get_request_info(const struct mg_connection *conn)
{
   if (!conn) {
      return NULL;
   }
#if defined(MG_ALLOW_USING_GET_REQUEST_INFO_FOR_RESPONSE)
   if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
      char txt[16];
      struct mg_workerTLS *tls =
          (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
 
      sprintf(txt, "%03i", conn->response_info.status_code);
      if (strlen(txt) == 3) {
         memcpy(tls->txtbuf, txt, 4);
      } else {
         strcpy(tls->txtbuf, "ERR");
      }
 
      ((struct mg_connection *)conn)->request_info.local_uri =
          tls->txtbuf; /* use thread safe buffer */
      ((struct mg_connection *)conn)->request_info.local_uri_raw =
          tls->txtbuf; /* use the same thread safe buffer */
      ((struct mg_connection *)conn)->request_info.request_uri =
          tls->txtbuf; /* use  the same thread safe buffer */
 
      ((struct mg_connection *)conn)->request_info.num_headers =
          conn->response_info.num_headers;
      memcpy(((struct mg_connection *)conn)->request_info.http_headers,
             conn->response_info.http_headers,
             sizeof(conn->response_info.http_headers));
   } else
#endif
       if (conn->connection_type != CONNECTION_TYPE_REQUEST) {
      return NULL;
   }
   return &conn->request_info;
}
 
 
const struct mg_response_info *
mg_get_response_info(const struct mg_connection *conn)
{
   if (!conn) {
      return NULL;
   }
   if (conn->connection_type != CONNECTION_TYPE_RESPONSE) {
      return NULL;
   }
   return &conn->response_info;
}
 
 
static const char *
get_proto_name(const struct mg_connection *conn)
{
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
   /* Depending on USE_WEBSOCKET and NO_SSL, some oft the protocols might be
    * not supported. Clang raises an "unreachable code" warning for parts of ?:
    * unreachable, but splitting into four different #ifdef clauses here is
    * more complicated.
    */
#endif
 
   const struct mg_request_info *ri = &conn->request_info;
 
   const char *proto = ((conn->protocol_type == PROTOCOL_TYPE_WEBSOCKET)
                            ? (ri->is_ssl ? "wss" : "ws")
                            : (ri->is_ssl ? "https" : "http"));
 
   return proto;
 
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
}
 
 
static int
mg_construct_local_link(const struct mg_connection *conn,
                        char *buf,
                        size_t buflen,
                        const char *define_proto,
                        int define_port,
                        const char *define_uri)
{
   if ((buflen < 1) || (buf == 0) || (conn == 0)) {
      return -1;
   } else {
      int truncated = 0;
      const struct mg_request_info *ri = &conn->request_info;
 
      const char *proto =
          (define_proto != NULL) ? define_proto : get_proto_name(conn);
      const char *uri =
          (define_uri != NULL)
              ? define_uri
              : ((ri->request_uri != NULL) ? ri->request_uri : ri->local_uri);
      int port = (define_port > 0) ? define_port : ri->server_port;
      int default_port = 80;
 
      if (uri == NULL) {
         return -1;
      }
 
#if defined(USE_X_DOM_SOCKET)
      if (conn->client.lsa.sa.sa_family == AF_UNIX) {
         /* TODO: Define and document a link for UNIX domain sockets. */
         /* There seems to be no official standard for this.
          * Common uses seem to be "httpunix://", "http.unix://" or
          * "http+unix://" as a protocol definition string, followed by
          * "localhost" or "127.0.0.1" or "/tmp/unix/path" or
          * "%2Ftmp%2Funix%2Fpath" (url % encoded) or
          * "localhost:%2Ftmp%2Funix%2Fpath" (domain socket path as port) or
          * "" (completely skipping the server name part). In any case, the
          * last part is the server local path. */
         const char *server_name = UNIX_DOMAIN_SOCKET_SERVER_NAME;
         mg_snprintf(conn,
                     &truncated,
                     buf,
                     buflen,
                     "%s.unix://%s%s",
                     proto,
                     server_name,
                     ri->local_uri);
         default_port = 0;
         return 0;
      }
#endif
 
      if (define_proto) {
         /* If we got a protocol name, use the default port accordingly. */
         if ((0 == strcmp(define_proto, "https"))
             || (0 == strcmp(define_proto, "wss"))) {
            default_port = 443;
         }
      } else if (ri->is_ssl) {
         /* If we did not get a protocol name, use TLS as default if it is
          * already used. */
         default_port = 443;
      }
 
      {
#if defined(USE_IPV6)
         int is_ipv6 = (conn->client.lsa.sa.sa_family == AF_INET6);
#endif
         int auth_domain_check_enabled =
             conn->dom_ctx->config[ENABLE_AUTH_DOMAIN_CHECK]
             && (!mg_strcasecmp(
                    conn->dom_ctx->config[ENABLE_AUTH_DOMAIN_CHECK], "yes"));
 
         const char *server_domain =
             conn->dom_ctx->config[AUTHENTICATION_DOMAIN];
 
         char portstr[16];
         char server_ip[48];
 
         if (port != default_port) {
            sprintf(portstr, ":%u", (unsigned)port);
         } else {
            portstr[0] = 0;
         }
 
         if (!auth_domain_check_enabled || !server_domain) {
 
            sockaddr_to_string(server_ip,
                               sizeof(server_ip),
                               &conn->client.lsa);
 
            server_domain = server_ip;
         }
 
         mg_snprintf(conn,
                     &truncated,
                     buf,
                     buflen,
#if defined(USE_IPV6)
                     "%s://%s%s%s%s%s",
                     proto,
                     (is_ipv6 && (server_domain == server_ip)) ? "[" : "",
                     server_domain,
                     (is_ipv6 && (server_domain == server_ip)) ? "]" : "",
#else
                     "%s://%s%s%s",
                     proto,
                     server_domain,
#endif
                     portstr,
                     ri->local_uri);
 
         if (truncated) {
            return -1;
         }
         return 0;
      }
   }
}
 
 
int
mg_get_request_link(const struct mg_connection *conn, char *buf, size_t buflen)
{
   return mg_construct_local_link(conn, buf, buflen, NULL, -1, NULL);
}
 
 
/* Skip the characters until one of the delimiters characters found.
 * 0-terminate resulting word. Skip the delimiter and following whitespaces.
 * Advance pointer to buffer to the next word. Return found 0-terminated
 * word.
 * Delimiters can be quoted with quotechar. */
static char *
skip_quoted(char **buf,
            const char *delimiters,
            const char *whitespace,
            char quotechar)
{
   char *p, *begin_word, *end_word, *end_whitespace;
 
   begin_word = *buf;
   end_word = begin_word + strcspn(begin_word, delimiters);
 
   /* Check for quotechar */
   if (end_word > begin_word) {
      p = end_word - 1;
      while (*p == quotechar) {
         /* While the delimiter is quoted, look for the next delimiter.
          */
         /* This happens, e.g., in calls from parse_auth_header,
          * if the user name contains a " character. */
 
         /* If there is anything beyond end_word, copy it. */
         if (*end_word != '\0') {
            size_t end_off = strcspn(end_word + 1, delimiters);
            memmove(p, end_word, end_off + 1);
            p += end_off; /* p must correspond to end_word - 1 */
            end_word += end_off + 1;
         } else {
            *p = '\0';
            break;
         }
      }
      for (p++; p < end_word; p++) {
         *p = '\0';
      }
   }
 
   if (*end_word == '\0') {
      *buf = end_word;
   } else {
 
#if defined(GCC_DIAGNOSTIC)
      /* Disable spurious conversion warning for GCC */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif /* defined(GCC_DIAGNOSTIC) */
 
      end_whitespace = end_word + strspn(&end_word[1], whitespace) + 1;
 
#if defined(GCC_DIAGNOSTIC)
#pragma GCC diagnostic pop
#endif /* defined(GCC_DIAGNOSTIC) */
 
      for (p = end_word; p < end_whitespace; p++) {
         *p = '\0';
      }
 
      *buf = end_whitespace;
   }
 
   return begin_word;
}
 
 
/* Return HTTP header value, or NULL if not found. */
static const char *
get_header(const struct mg_header *hdr, int num_hdr, const char *name)
{
   int i;
   for (i = 0; i < num_hdr; i++) {
      if (!mg_strcasecmp(name, hdr[i].name)) {
         return hdr[i].value;
      }
   }
 
   return NULL;
}
 
 
#if defined(USE_WEBSOCKET)
/* Retrieve requested HTTP header multiple values, and return the number of
 * found occurrences */
static int
get_req_headers(const struct mg_request_info *ri,
                const char *name,
                const char **output,
                int output_max_size)
{
   int i;
   int cnt = 0;
   if (ri) {
      for (i = 0; i < ri->num_headers && cnt < output_max_size; i++) {
         if (!mg_strcasecmp(name, ri->http_headers[i].name)) {
            output[cnt++] = ri->http_headers[i].value;
         }
      }
   }
   return cnt;
}
#endif
 
 
const char *
mg_get_header(const struct mg_connection *conn, const char *name)
{
   if (!conn) {
      return NULL;
   }
 
   if (conn->connection_type == CONNECTION_TYPE_REQUEST) {
      return get_header(conn->request_info.http_headers,
                        conn->request_info.num_headers,
                        name);
   }
   if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
      return get_header(conn->response_info.http_headers,
                        conn->response_info.num_headers,
                        name);
   }
   return NULL;
}
 
 
static const char *
get_http_version(const struct mg_connection *conn)
{
   if (!conn) {
      return NULL;
   }
 
   if (conn->connection_type == CONNECTION_TYPE_REQUEST) {
      return conn->request_info.http_version;
   }
   if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
      return conn->response_info.http_version;
   }
   return NULL;
}
 
 
/* A helper function for traversing a comma separated list of values.
 * It returns a list pointer shifted to the next value, or NULL if the end
 * of the list found.
 * Value is stored in val vector. If value has form "x=y", then eq_val
 * vector is initialized to point to the "y" part, and val vector length
 * is adjusted to point only to "x". */
static const char *
next_option(const char *list, struct vec *val, struct vec *eq_val)
{
   int end;
 
reparse:
   if (val == NULL || list == NULL || *list == '\0') {
      /* End of the list */
      return NULL;
   }
 
   /* Skip over leading LWS */
   while (*list == ' ' || *list == '\t')
      list++;
 
   val->ptr = list;
   if ((list = strchr(val->ptr, ',')) != NULL) {
      /* Comma found. Store length and shift the list ptr */
      val->len = ((size_t)(list - val->ptr));
      list++;
   } else {
      /* This value is the last one */
      list = val->ptr + strlen(val->ptr);
      val->len = ((size_t)(list - val->ptr));
   }
 
   /* Adjust length for trailing LWS */
   end = (int)val->len - 1;
   while (end >= 0 && ((val->ptr[end] == ' ') || (val->ptr[end] == '\t')))
      end--;
   val->len = (size_t)(end) + (size_t)(1);
 
   if (val->len == 0) {
      /* Ignore any empty entries. */
      goto reparse;
   }
 
   if (eq_val != NULL) {
      /* Value has form "x=y", adjust pointers and lengths
       * so that val points to "x", and eq_val points to "y". */
      eq_val->len = 0;
      eq_val->ptr = (const char *)memchr(val->ptr, '=', val->len);
      if (eq_val->ptr != NULL) {
         eq_val->ptr++; /* Skip over '=' character */
         eq_val->len = ((size_t)(val->ptr - eq_val->ptr)) + val->len;
         val->len = ((size_t)(eq_val->ptr - val->ptr)) - 1;
      }
   }
 
   return list;
}
 
 
/* A helper function for checking if a comma separated list of values
 * contains
 * the given option (case insensitvely).
 * 'header' can be NULL, in which case false is returned. */
static int
header_has_option(const char *header, const char *option)
{
   struct vec opt_vec;
   struct vec eq_vec;
 
   DEBUG_ASSERT(option != NULL);
   DEBUG_ASSERT(option[0] != '\0');
 
   while ((header = next_option(header, &opt_vec, &eq_vec)) != NULL) {
      if (mg_strncasecmp(option, opt_vec.ptr, opt_vec.len) == 0)
         return 1;
   }
 
   return 0;
}
 
 
/* Perform case-insensitive match of string against pattern */
static ptrdiff_t
match_prefix(const char *pattern, size_t pattern_len, const char *str)
{
   const char *or_str;
   ptrdiff_t i, j, len, res;
 
   if ((or_str = (const char *)memchr(pattern, '|', pattern_len)) != NULL) {
      res = match_prefix(pattern, (size_t)(or_str - pattern), str);
      return (res > 0) ? res
                       : match_prefix(or_str + 1,
                                      (size_t)((pattern + pattern_len)
                                               - (or_str + 1)),
                                      str);
   }
 
   for (i = 0, j = 0; (i < (ptrdiff_t)pattern_len); i++, j++) {
      if ((pattern[i] == '?') && (str[j] != '\0')) {
         continue;
      } else if (pattern[i] == '$') {
         return (str[j] == '\0') ? j : -1;
      } else if (pattern[i] == '*') {
         i++;
         if (pattern[i] == '*') {
            i++;
            len = (ptrdiff_t)strlen(str + j);
         } else {
            len = (ptrdiff_t)strcspn(str + j, "/");
         }
         if (i == (ptrdiff_t)pattern_len) {
            return j + len;
         }
         do {
            res = match_prefix(pattern + i,
                               (pattern_len - (size_t)i),
                               str + j + len);
         } while (res == -1 && len-- > 0);
         return (res == -1) ? -1 : j + res + len;
      } else if (lowercase(&pattern[i]) != lowercase(&str[j])) {
         return -1;
      }
   }
   return (ptrdiff_t)j;
}
 
 
static ptrdiff_t
match_prefix_strlen(const char *pattern, const char *str)
{
   if (pattern == NULL) {
      return -1;
   }
   return match_prefix(pattern, strlen(pattern), str);
}
 
 
/* HTTP 1.1 assumes keep alive if "Connection:" header is not set
 * This function must tolerate situations when connection info is not
 * set up, for example if request parsing failed. */
static int
should_keep_alive(const struct mg_connection *conn)
{
   const char *http_version;
   const char *header;
 
   /* First satisfy needs of the server */
   if ((conn == NULL) || conn->must_close) {
      /* Close, if civetweb framework needs to close */
      return 0;
   }
 
   if (mg_strcasecmp(conn->dom_ctx->config[ENABLE_KEEP_ALIVE], "yes") != 0) {
      /* Close, if keep alive is not enabled */
      return 0;
   }
 
   /* Check explicit wish of the client */
   header = mg_get_header(conn, "Connection");
   if (header) {
      /* If there is a connection header from the client, obey */
      if (header_has_option(header, "keep-alive")) {
         return 1;
      }
      return 0;
   }
 
   /* Use default of the standard */
   http_version = get_http_version(conn);
   if (http_version && (0 == strcmp(http_version, "1.1"))) {
      /* HTTP 1.1 default is keep alive */
      return 1;
   }
 
   /* HTTP 1.0 (and earlier) default is to close the connection */
   return 0;
}
 
 
static int
should_decode_url(const struct mg_connection *conn)
{
   if (!conn || !conn->dom_ctx) {
      return 0;
   }
 
   return (mg_strcasecmp(conn->dom_ctx->config[DECODE_URL], "yes") == 0);
}
 
 
static int
should_decode_query_string(const struct mg_connection *conn)
{
   if (!conn || !conn->dom_ctx) {
      return 0;
   }
 
   return (mg_strcasecmp(conn->dom_ctx->config[DECODE_QUERY_STRING], "yes")
           == 0);
}
 
 
static const char *
suggest_connection_header(const struct mg_connection *conn)
{
   return should_keep_alive(conn) ? "keep-alive" : "close";
}
 
 
#include "response.inl"
 
 
static void
send_no_cache_header(struct mg_connection *conn)
{
   /* Send all current and obsolete cache opt-out directives. */
   mg_response_header_add(conn,
                          "Cache-Control",
                          "no-cache, no-store, "
                          "must-revalidate, private, max-age=0",
                          -1);
   mg_response_header_add(conn, "Expires", "0", -1);
 
   if (conn->protocol_type == PROTOCOL_TYPE_HTTP1) {
      /* Obsolete, but still send it for HTTP/1.0 */
      mg_response_header_add(conn, "Pragma", "no-cache", -1);
   }
}
 
 
static void
send_static_cache_header(struct mg_connection *conn)
{
#if !defined(NO_CACHING)
   int max_age;
   char val[64];
 
   const char *cache_control =
       conn->dom_ctx->config[STATIC_FILE_CACHE_CONTROL];
 
   /* If there is a full cache-control option configured,0 use it */
   if (cache_control != NULL) {
      mg_response_header_add(conn, "Cache-Control", cache_control, -1);
      return;
   }
 
   /* Read the server config to check how long a file may be cached.
    * The configuration is in seconds. */
   max_age = atoi(conn->dom_ctx->config[STATIC_FILE_MAX_AGE]);
   if (max_age <= 0) {
      /* 0 means "do not cache". All values <0 are reserved
       * and may be used differently in the future. */
      /* If a file should not be cached, do not only send
       * max-age=0, but also pragmas and Expires headers. */
      send_no_cache_header(conn);
      return;
   }
 
   /* Use "Cache-Control: max-age" instead of "Expires" header.
    * Reason: see https://www.mnot.net/blog/2007/05/15/expires_max-age */
   /* See also https://www.mnot.net/cache_docs/ */
   /* According to RFC 2616, Section 14.21, caching times should not exceed
    * one year. A year with 365 days corresponds to 31536000 seconds, a
    * leap
    * year to 31622400 seconds. For the moment, we just send whatever has
    * been configured, still the behavior for >1 year should be considered
    * as undefined. */
   mg_snprintf(
       conn, NULL, val, sizeof(val), "max-age=%lu", (unsigned long)max_age);
   mg_response_header_add(conn, "Cache-Control", val, -1);
 
#else  /* NO_CACHING */
 
   send_no_cache_header(conn);
#endif /* !NO_CACHING */
}
 
 
static void
send_additional_header(struct mg_connection *conn)
{
   const char *header = conn->dom_ctx->config[ADDITIONAL_HEADER];
 
#if !defined(NO_SSL)
   if (conn->dom_ctx->config[STRICT_HTTPS_MAX_AGE]) {
      long max_age = atol(conn->dom_ctx->config[STRICT_HTTPS_MAX_AGE]);
      if (max_age >= 0) {
         char val[64];
         mg_snprintf(conn,
                     NULL,
                     val,
                     sizeof(val),
                     "max-age=%lu",
                     (unsigned long)max_age);
         mg_response_header_add(conn, "Strict-Transport-Security", val, -1);
      }
   }
#endif
 
   if (header && header[0]) {
      mg_response_header_add_lines(conn, header);
   }
}
 
 
#if !defined(NO_FILESYSTEMS)
static void handle_file_based_request(struct mg_connection *conn,
                                      const char *path,
                                      struct mg_file *filep);
#endif /* NO_FILESYSTEMS */
 
 
const char *
mg_get_response_code_text(const struct mg_connection *conn, int response_code)
{
   /* See IANA HTTP status code assignment:
    * http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
    */
 
   switch (response_code) {
      /* RFC2616 Section 10.1 - Informational 1xx */
   case 100:
      return "Continue"; /* RFC2616 Section 10.1.1 */
   case 101:
      return "Switching Protocols"; /* RFC2616 Section 10.1.2 */
   case 102:
      return "Processing"; /* RFC2518 Section 10.1 */
 
      /* RFC2616 Section 10.2 - Successful 2xx */
   case 200:
      return "OK"; /* RFC2616 Section 10.2.1 */
   case 201:
      return "Created"; /* RFC2616 Section 10.2.2 */
   case 202:
      return "Accepted"; /* RFC2616 Section 10.2.3 */
   case 203:
      return "Non-Authoritative Information"; /* RFC2616 Section 10.2.4 */
   case 204:
      return "No Content"; /* RFC2616 Section 10.2.5 */
   case 205:
      return "Reset Content"; /* RFC2616 Section 10.2.6 */
   case 206:
      return "Partial Content"; /* RFC2616 Section 10.2.7 */
   case 207:
      return "Multi-Status"; /* RFC2518 Section 10.2, RFC4918 Section 11.1
                              */
   case 208:
      return "Already Reported"; /* RFC5842 Section 7.1 */
 
   case 226:
      return "IM used"; /* RFC3229 Section 10.4.1 */
 
      /* RFC2616 Section 10.3 - Redirection 3xx */
   case 300:
      return "Multiple Choices"; /* RFC2616 Section 10.3.1 */
   case 301:
      return "Moved Permanently"; /* RFC2616 Section 10.3.2 */
   case 302:
      return "Found"; /* RFC2616 Section 10.3.3 */
   case 303:
      return "See Other"; /* RFC2616 Section 10.3.4 */
   case 304:
      return "Not Modified"; /* RFC2616 Section 10.3.5 */
   case 305:
      return "Use Proxy"; /* RFC2616 Section 10.3.6 */
   case 307:
      return "Temporary Redirect"; /* RFC2616 Section 10.3.8 */
   case 308:
      return "Permanent Redirect"; /* RFC7238 Section 3 */
 
      /* RFC2616 Section 10.4 - Client Error 4xx */
   case 400:
      return "Bad Request"; /* RFC2616 Section 10.4.1 */
   case 401:
      return "Unauthorized"; /* RFC2616 Section 10.4.2 */
   case 402:
      return "Payment Required"; /* RFC2616 Section 10.4.3 */
   case 403:
      return "Forbidden"; /* RFC2616 Section 10.4.4 */
   case 404:
      return "Not Found"; /* RFC2616 Section 10.4.5 */
   case 405:
      return "Method Not Allowed"; /* RFC2616 Section 10.4.6 */
   case 406:
      return "Not Acceptable"; /* RFC2616 Section 10.4.7 */
   case 407:
      return "Proxy Authentication Required"; /* RFC2616 Section 10.4.8 */
   case 408:
      return "Request Time-out"; /* RFC2616 Section 10.4.9 */
   case 409:
      return "Conflict"; /* RFC2616 Section 10.4.10 */
   case 410:
      return "Gone"; /* RFC2616 Section 10.4.11 */
   case 411:
      return "Length Required"; /* RFC2616 Section 10.4.12 */
   case 412:
      return "Precondition Failed"; /* RFC2616 Section 10.4.13 */
   case 413:
      return "Request Entity Too Large"; /* RFC2616 Section 10.4.14 */
   case 414:
      return "Request-URI Too Large"; /* RFC2616 Section 10.4.15 */
   case 415:
      return "Unsupported Media Type"; /* RFC2616 Section 10.4.16 */
   case 416:
      return "Requested range not satisfiable"; /* RFC2616 Section 10.4.17
                                                 */
   case 417:
      return "Expectation Failed"; /* RFC2616 Section 10.4.18 */
 
   case 421:
      return "Misdirected Request"; /* RFC7540 Section 9.1.2 */
   case 422:
      return "Unproccessable entity"; /* RFC2518 Section 10.3, RFC4918
                                       * Section 11.2 */
   case 423:
      return "Locked"; /* RFC2518 Section 10.4, RFC4918 Section 11.3 */
   case 424:
      return "Failed Dependency"; /* RFC2518 Section 10.5, RFC4918
                                   * Section 11.4 */
 
   case 426:
      return "Upgrade Required"; /* RFC 2817 Section 4 */
 
   case 428:
      return "Precondition Required"; /* RFC 6585, Section 3 */
   case 429:
      return "Too Many Requests"; /* RFC 6585, Section 4 */
 
   case 431:
      return "Request Header Fields Too Large"; /* RFC 6585, Section 5 */
 
   case 451:
      return "Unavailable For Legal Reasons"; /* draft-tbray-http-legally-restricted-status-05,
                                               * Section 3 */
 
      /* RFC2616 Section 10.5 - Server Error 5xx */
   case 500:
      return "Internal Server Error"; /* RFC2616 Section 10.5.1 */
   case 501:
      return "Not Implemented"; /* RFC2616 Section 10.5.2 */
   case 502:
      return "Bad Gateway"; /* RFC2616 Section 10.5.3 */
   case 503:
      return "Service Unavailable"; /* RFC2616 Section 10.5.4 */
   case 504:
      return "Gateway Time-out"; /* RFC2616 Section 10.5.5 */
   case 505:
      return "HTTP Version not supported"; /* RFC2616 Section 10.5.6 */
   case 506:
      return "Variant Also Negotiates"; /* RFC 2295, Section 8.1 */
   case 507:
      return "Insufficient Storage"; /* RFC2518 Section 10.6, RFC4918
                                      * Section 11.5 */
   case 508:
      return "Loop Detected"; /* RFC5842 Section 7.1 */
 
   case 510:
      return "Not Extended"; /* RFC 2774, Section 7 */
   case 511:
      return "Network Authentication Required"; /* RFC 6585, Section 6 */
 
      /* Other status codes, not shown in the IANA HTTP status code
       * assignment.
       * E.g., "de facto" standards due to common use, ... */
   case 418:
      return "I am a teapot"; /* RFC2324 Section 2.3.2 */
   case 419:
      return "Authentication Timeout"; /* common use */
   case 420:
      return "Enhance Your Calm"; /* common use */
   case 440:
      return "Login Timeout"; /* common use */
   case 509:
      return "Bandwidth Limit Exceeded"; /* common use */
 
   default:
      /* This error code is unknown. This should not happen. */
      if (conn) {
         mg_cry_internal(conn,
                         "Unknown HTTP response code: %u",
                         response_code);
      }
 
      /* Return at least a category according to RFC 2616 Section 10. */
      if (response_code >= 100 && response_code < 200) {
         /* Unknown informational status code */
         return "Information";
      }
      if (response_code >= 200 && response_code < 300) {
         /* Unknown success code */
         return "Success";
      }
      if (response_code >= 300 && response_code < 400) {
         /* Unknown redirection code */
         return "Redirection";
      }
      if (response_code >= 400 && response_code < 500) {
         /* Unknown request error code */
         return "Client Error";
      }
      if (response_code >= 500 && response_code < 600) {
         /* Unknown server error code */
         return "Server Error";
      }
 
      /* Response code not even within reasonable range */
      return "";
   }
}
 
 
static int
mg_send_http_error_impl(struct mg_connection *conn,
                        int status,
                        const char *fmt,
                        va_list args)
{
   char errmsg_buf[MG_BUF_LEN];
   va_list ap;
   int has_body;
 
#if !defined(NO_FILESYSTEMS)
   char path_buf[UTF8_PATH_MAX];
   int len, i, page_handler_found, scope, truncated;
   const char *error_handler = NULL;
   struct mg_file error_page_file = STRUCT_FILE_INITIALIZER;
   const char *error_page_file_ext, *tstr;
#endif /* NO_FILESYSTEMS */
   int handled_by_callback = 0;
 
   if ((conn == NULL) || (fmt == NULL)) {
      return -2;
   }
 
   /* Set status (for log) */
   conn->status_code = status;
 
   /* Errors 1xx, 204 and 304 MUST NOT send a body */
   has_body = ((status > 199) && (status != 204) && (status != 304));
 
   /* Prepare message in buf, if required */
   if (has_body
       || (!conn->in_error_handler
           && (conn->phys_ctx->callbacks.http_error != NULL))) {
      /* Store error message in errmsg_buf */
      va_copy(ap, args);
      mg_vsnprintf(conn, NULL, errmsg_buf, sizeof(errmsg_buf), fmt, ap);
      va_end(ap);
      /* In a debug build, print all html errors */
      DEBUG_TRACE("Error %i - [%s]", status, errmsg_buf);
   }
 
   /* If there is a http_error callback, call it.
    * But don't do it recursively, if callback calls mg_send_http_error again.
    */
   if (!conn->in_error_handler
       && (conn->phys_ctx->callbacks.http_error != NULL)) {
      /* Mark in_error_handler to avoid recursion and call user callback. */
      conn->in_error_handler = 1;
      handled_by_callback =
          (conn->phys_ctx->callbacks.http_error(conn, status, errmsg_buf)
           == 0);
      conn->in_error_handler = 0;
   }
 
   if (!handled_by_callback) {
      /* Check for recursion */
      if (conn->in_error_handler) {
         DEBUG_TRACE(
             "Recursion when handling error %u - fall back to default",
             status);
#if !defined(NO_FILESYSTEMS)
      } else {
         /* Send user defined error pages, if defined */
         error_handler = conn->dom_ctx->config[ERROR_PAGES];
         error_page_file_ext = conn->dom_ctx->config[INDEX_FILES];
         page_handler_found = 0;
 
         if (error_handler != NULL) {
            for (scope = 1; (scope <= 3) && !page_handler_found; scope++) {
               switch (scope) {
               case 1: /* Handler for specific error, e.g. 404 error */
                  mg_snprintf(conn,
                              &truncated,
                              path_buf,
                              sizeof(path_buf) - 32,
                              "%serror%03u.",
                              error_handler,
                              status);
                  break;
               case 2: /* Handler for error group, e.g., 5xx error
                        * handler
                        * for all server errors (500-599) */
                  mg_snprintf(conn,
                              &truncated,
                              path_buf,
                              sizeof(path_buf) - 32,
                              "%serror%01uxx.",
                              error_handler,
                              status / 100);
                  break;
               default: /* Handler for all errors */
                  mg_snprintf(conn,
                              &truncated,
                              path_buf,
                              sizeof(path_buf) - 32,
                              "%serror.",
                              error_handler);
                  break;
               }
 
               /* String truncation in buf may only occur if
                * error_handler is too long. This string is
                * from the config, not from a client. */
               (void)truncated;
 
               /* The following code is redundant, but it should avoid
                * false positives in static source code analyzers and
                * vulnerability scanners.
                */
               path_buf[sizeof(path_buf) - 32] = 0;
               len = (int)strlen(path_buf);
               if (len > (int)sizeof(path_buf) - 32) {
                  len = (int)sizeof(path_buf) - 32;
               }
 
               /* Start with the file extenstion from the configuration. */
               tstr = strchr(error_page_file_ext, '.');
 
               while (tstr) {
                  for (i = 1;
                       (i < 32) && (tstr[i] != 0) && (tstr[i] != ',');
                       i++) {
                     /* buffer overrun is not possible here, since
                      * (i < 32) && (len < sizeof(path_buf) - 32)
                      * ==> (i + len) < sizeof(path_buf) */
                     path_buf[len + i - 1] = tstr[i];
                  }
                  /* buffer overrun is not possible here, since
                   * (i <= 32) && (len < sizeof(path_buf) - 32)
                   * ==> (i + len) <= sizeof(path_buf) */
                  path_buf[len + i - 1] = 0;
 
                  if (mg_stat(conn, path_buf, &error_page_file.stat)) {
                     DEBUG_TRACE("Check error page %s - found",
                                 path_buf);
                     page_handler_found = 1;
                     break;
                  }
                  DEBUG_TRACE("Check error page %s - not found",
                              path_buf);
 
                  /* Continue with the next file extenstion from the
                   * configuration (if there is a next one). */
                  tstr = strchr(tstr + i, '.');
               }
            }
         }
 
         if (page_handler_found) {
            conn->in_error_handler = 1;
            handle_file_based_request(conn, path_buf, &error_page_file);
            conn->in_error_handler = 0;
            return 0;
         }
#endif /* NO_FILESYSTEMS */
      }
 
      /* No custom error page. Send default error page. */
      conn->must_close = 1;
      mg_response_header_start(conn, status);
      send_no_cache_header(conn);
      send_additional_header(conn);
      if (has_body) {
         mg_response_header_add(conn,
                                "Content-Type",
                                "text/plain; charset=utf-8",
                                -1);
      }
      mg_response_header_send(conn);
 
      /* HTTP responses 1xx, 204 and 304 MUST NOT send a body */
      if (has_body) {
         /* For other errors, send a generic error message. */
         const char *status_text = mg_get_response_code_text(conn, status);
         mg_printf(conn, "Error %d: %s\n", status, status_text);
         mg_write(conn, errmsg_buf, strlen(errmsg_buf));
 
      } else {
         /* No body allowed. Close the connection. */
         DEBUG_TRACE("Error %i", status);
      }
   }
   return 0;
}
 
 
int
mg_send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
{
   va_list ap;
   int ret;
 
   va_start(ap, fmt);
   ret = mg_send_http_error_impl(conn, status, fmt, ap);
   va_end(ap);
 
   return ret;
}
 
 
int
mg_send_http_ok(struct mg_connection *conn,
                const char *mime_type,
                long long content_length)
{
   if ((mime_type == NULL) || (*mime_type == 0)) {
      /* No content type defined: default to text/html */
      mime_type = "text/html";
   }
 
   mg_response_header_start(conn, 200);
   send_no_cache_header(conn);
   send_additional_header(conn);
   mg_response_header_add(conn, "Content-Type", mime_type, -1);
   if (content_length < 0) {
      /* Size not known. Use chunked encoding (HTTP/1.x) */
      if (conn->protocol_type == PROTOCOL_TYPE_HTTP1) {
         /* Only HTTP/1.x defines "chunked" encoding, HTTP/2 does not*/
         mg_response_header_add(conn, "Transfer-Encoding", "chunked", -1);
      }
   } else {
      char len[32];
      int trunc = 0;
      mg_snprintf(conn,
                  &trunc,
                  len,
                  sizeof(len),
                  "%" UINT64_FMT,
                  (uint64_t)content_length);
      if (!trunc) {
         /* Since 32 bytes is enough to hold any 64 bit decimal number,
          * !trunc is always true */
         mg_response_header_add(conn, "Content-Length", len, -1);
      }
   }
   mg_response_header_send(conn);
 
   return 0;
}
 
 
int
mg_send_http_redirect(struct mg_connection *conn,
                      const char *target_url,
                      int redirect_code)
{
   /* Send a 30x redirect response.
    *
    * Redirect types (status codes):
    *
    * Status | Perm/Temp | Method              | Version
    *   301  | permanent | POST->GET undefined | HTTP/1.0
    *   302  | temporary | POST->GET undefined | HTTP/1.0
    *   303  | temporary | always use GET      | HTTP/1.1
    *   307  | temporary | always keep method  | HTTP/1.1
    *   308  | permanent | always keep method  | HTTP/1.1
    */
   const char *redirect_text;
   int ret;
   size_t content_len = 0;
#if defined(MG_SEND_REDIRECT_BODY)
   char reply[MG_BUF_LEN];
#endif
 
   /* In case redirect_code=0, use 307. */
   if (redirect_code == 0) {
      redirect_code = 307;
   }
 
   /* In case redirect_code is none of the above, return error. */
   if ((redirect_code != 301) && (redirect_code != 302)
       && (redirect_code != 303) && (redirect_code != 307)
       && (redirect_code != 308)) {
      /* Parameter error */
      return -2;
   }
 
   /* Get proper text for response code */
   redirect_text = mg_get_response_code_text(conn, redirect_code);
 
   /* If target_url is not defined, redirect to "/". */
   if ((target_url == NULL) || (*target_url == 0)) {
      target_url = "/";
   }
 
#if defined(MG_SEND_REDIRECT_BODY)
   /* TODO: condition name? */
 
   /* Prepare a response body with a hyperlink.
    *
    * According to RFC2616 (and RFC1945 before):
    * Unless the request method was HEAD, the entity of the
    * response SHOULD contain a short hypertext note with a hyperlink to
    * the new URI(s).
    *
    * However, this response body is not useful in M2M communication.
    * Probably the original reason in the RFC was, clients not supporting
    * a 30x HTTP redirect could still show the HTML page and let the user
    * press the link. Since current browsers support 30x HTTP, the additional
    * HTML body does not seem to make sense anymore.
    *
    * The new RFC7231 (Section 6.4) does no longer recommend it ("SHOULD"),
    * but it only notes:
    * The server's response payload usually contains a short
    * hypertext note with a hyperlink to the new URI(s).
    *
    * Deactivated by default. If you need the 30x body, set the define.
    */
   mg_snprintf(
       conn,
       NULL /* ignore truncation */,
       reply,
       sizeof(reply),
       "<html><head>%s</head><body><a href=\"%s\">%s</a></body></html>",
       redirect_text,
       target_url,
       target_url);
   content_len = strlen(reply);
#endif
 
   /* Do not send any additional header. For all other options,
    * including caching, there are suitable defaults. */
   ret = mg_printf(conn,
                   "HTTP/1.1 %i %s\r\n"
                   "Location: %s\r\n"
                   "Content-Length: %u\r\n"
                   "Connection: %s\r\n\r\n",
                   redirect_code,
                   redirect_text,
                   target_url,
                   (unsigned int)content_len,
                   suggest_connection_header(conn));
 
#if defined(MG_SEND_REDIRECT_BODY)
   /* Send response body */
   if (ret > 0) {
      /* ... unless it is a HEAD request */
      if (0 != strcmp(conn->request_info.request_method, "HEAD")) {
         ret = mg_write(conn, reply, content_len);
      }
   }
#endif
 
   return (ret > 0) ? ret : -1;
}
 
 
#if defined(_WIN32)
/* Create substitutes for POSIX functions in Win32. */
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
 
static int
pthread_mutex_init(pthread_mutex_t *mutex, void *unused)
{
   (void)unused;
   /* Always initialize as PTHREAD_MUTEX_RECURSIVE */
   InitializeCriticalSection(&mutex->sec);
   return 0;
}
 
 
static int
pthread_mutex_destroy(pthread_mutex_t *mutex)
{
   DeleteCriticalSection(&mutex->sec);
   return 0;
}
 
 
static int
pthread_mutex_lock(pthread_mutex_t *mutex)
{
   EnterCriticalSection(&mutex->sec);
   return 0;
}
 
 
static int
pthread_mutex_unlock(pthread_mutex_t *mutex)
{
   LeaveCriticalSection(&mutex->sec);
   return 0;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_init(pthread_cond_t *cv, const void *unused)
{
   (void)unused;
   (void)pthread_mutex_init(&cv->threadIdSec, &pthread_mutex_attr);
   cv->waiting_thread = NULL;
   return 0;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_timedwait(pthread_cond_t *cv,
                       pthread_mutex_t *mutex,
                       FUNCTION_MAY_BE_UNUSED const struct timespec *abstime)
{
   struct mg_workerTLS **ptls,
       *tls = (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
   int ok;
   uint64_t nsnow, nswaitabs;
   int64_t nswaitrel;
   DWORD mswaitrel;
 
   pthread_mutex_lock(&cv->threadIdSec);
   /* Add this thread to cv's waiting list */
   ptls = &cv->waiting_thread;
   for (; *ptls != NULL; ptls = &(*ptls)->next_waiting_thread)
      ;
   tls->next_waiting_thread = NULL;
   *ptls = tls;
   pthread_mutex_unlock(&cv->threadIdSec);
 
   if (abstime) {
      nsnow = mg_get_current_time_ns();
      nswaitabs =
          (((uint64_t)abstime->tv_sec) * 1000000000) + abstime->tv_nsec;
      nswaitrel = nswaitabs - nsnow;
      if (nswaitrel < 0) {
         nswaitrel = 0;
      }
      mswaitrel = (DWORD)(nswaitrel / 1000000);
   } else {
      mswaitrel = (DWORD)INFINITE;
   }
 
   pthread_mutex_unlock(mutex);
   ok = (WAIT_OBJECT_0
         == WaitForSingleObject(tls->pthread_cond_helper_mutex, mswaitrel));
   if (!ok) {
      ok = 1;
      pthread_mutex_lock(&cv->threadIdSec);
      ptls = &cv->waiting_thread;
      for (; *ptls != NULL; ptls = &(*ptls)->next_waiting_thread) {
         if (*ptls == tls) {
            *ptls = tls->next_waiting_thread;
            ok = 0;
            break;
         }
      }
      pthread_mutex_unlock(&cv->threadIdSec);
      if (ok) {
         WaitForSingleObject(tls->pthread_cond_helper_mutex,
                             (DWORD)INFINITE);
      }
   }
   /* This thread has been removed from cv's waiting list */
   pthread_mutex_lock(mutex);
 
   return ok ? 0 : -1;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex)
{
   return pthread_cond_timedwait(cv, mutex, NULL);
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_signal(pthread_cond_t *cv)
{
   HANDLE wkup = NULL;
   BOOL ok = FALSE;
 
   pthread_mutex_lock(&cv->threadIdSec);
   if (cv->waiting_thread) {
      wkup = cv->waiting_thread->pthread_cond_helper_mutex;
      cv->waiting_thread = cv->waiting_thread->next_waiting_thread;
 
      ok = SetEvent(wkup);
      DEBUG_ASSERT(ok);
   }
   pthread_mutex_unlock(&cv->threadIdSec);
 
   return ok ? 0 : 1;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_broadcast(pthread_cond_t *cv)
{
   pthread_mutex_lock(&cv->threadIdSec);
   while (cv->waiting_thread) {
      pthread_cond_signal(cv);
   }
   pthread_mutex_unlock(&cv->threadIdSec);
 
   return 0;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_destroy(pthread_cond_t *cv)
{
   pthread_mutex_lock(&cv->threadIdSec);
   DEBUG_ASSERT(cv->waiting_thread == NULL);
   pthread_mutex_unlock(&cv->threadIdSec);
   pthread_mutex_destroy(&cv->threadIdSec);
 
   return 0;
}
 
 
#if defined(ALTERNATIVE_QUEUE)
FUNCTION_MAY_BE_UNUSED
static void *
event_create(void)
{
   return (void *)CreateEvent(NULL, FALSE, FALSE, NULL);
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
event_wait(void *eventhdl)
{
   int res = WaitForSingleObject((HANDLE)eventhdl, (DWORD)INFINITE);
   return (res == WAIT_OBJECT_0);
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
event_signal(void *eventhdl)
{
   return (int)SetEvent((HANDLE)eventhdl);
}
 
 
FUNCTION_MAY_BE_UNUSED
static void
event_destroy(void *eventhdl)
{
   CloseHandle((HANDLE)eventhdl);
}
#endif
 
 
#if defined(GCC_DIAGNOSTIC)
/* Enable unused function warning again */
#pragma GCC diagnostic pop
#endif
 
 
/* For Windows, change all slashes to backslashes in path names. */
static void
change_slashes_to_backslashes(char *path)
{
   int i;
 
   for (i = 0; path[i] != '\0'; i++) {
      if (path[i] == '/') {
         path[i] = '\\';
      }
 
      /* remove double backslash (check i > 0 to preserve UNC paths,
       * like \\server\file.txt) */
      if ((i > 0) && (path[i] == '\\')) {
         while ((path[i + 1] == '\\') || (path[i + 1] == '/')) {
            (void)memmove(path + i + 1, path + i + 2, strlen(path + i + 1));
         }
      }
   }
}
 
 
static int
mg_wcscasecmp(const wchar_t *s1, const wchar_t *s2)
{
   int diff;
 
   do {
      diff = ((*s1 >= L'A') && (*s1 <= L'Z') ? (*s1 - L'A' + L'a') : *s1)
             - ((*s2 >= L'A') && (*s2 <= L'Z') ? (*s2 - L'A' + L'a') : *s2);
      s1++;
      s2++;
   } while ((diff == 0) && (s1[-1] != L'\0'));
 
   return diff;
}
 
 
/* Encode 'path' which is assumed UTF-8 string, into UNICODE string.
 * wbuf and wbuf_len is a target buffer and its length. */
static void
path_to_unicode(const struct mg_connection *conn,
                const char *path,
                wchar_t *wbuf,
                size_t wbuf_len)
{
   char buf[UTF8_PATH_MAX], buf2[UTF8_PATH_MAX];
   wchar_t wbuf2[UTF16_PATH_MAX + 1];
   DWORD long_len, err;
   int (*fcompare)(const wchar_t *, const wchar_t *) = mg_wcscasecmp;
 
   mg_strlcpy(buf, path, sizeof(buf));
   change_slashes_to_backslashes(buf);
 
   /* Convert to Unicode and back. If doubly-converted string does not
    * match the original, something is fishy, reject. */
   memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
   MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int)wbuf_len);
   WideCharToMultiByte(
       CP_UTF8, 0, wbuf, (int)wbuf_len, buf2, sizeof(buf2), NULL, NULL);
   if (strcmp(buf, buf2) != 0) {
      wbuf[0] = L'\0';
   }
 
   /* Windows file systems are not case sensitive, but you can still use
    * uppercase and lowercase letters (on all modern file systems).
    * The server can check if the URI uses the same upper/lowercase
    * letters an the file system, effectively making Windows servers
    * case sensitive (like Linux servers are). It is still not possible
    * to use two files with the same name in different cases on Windows
    * (like /a and /A) - this would be possible in Linux.
    * As a default, Windows is not case sensitive, but the case sensitive
    * file name check can be activated by an additional configuration. */
   if (conn) {
      if (conn->dom_ctx->config[CASE_SENSITIVE_FILES]
          && !mg_strcasecmp(conn->dom_ctx->config[CASE_SENSITIVE_FILES],
                            "yes")) {
         /* Use case sensitive compare function */
         fcompare = wcscmp;
      }
   }
   (void)conn; /* conn is currently unused */
 
   /* Only accept a full file path, not a Windows short (8.3) path. */
   memset(wbuf2, 0, ARRAY_SIZE(wbuf2) * sizeof(wchar_t));
   long_len = GetLongPathNameW(wbuf, wbuf2, ARRAY_SIZE(wbuf2) - 1);
   if (long_len == 0) {
      err = GetLastError();
      if (err == ERROR_FILE_NOT_FOUND) {
         /* File does not exist. This is not always a problem here. */
         return;
      }
   }
   if ((long_len >= ARRAY_SIZE(wbuf2)) || (fcompare(wbuf, wbuf2) != 0)) {
      /* Short name is used. */
      wbuf[0] = L'\0';
   }
}
 
 
#if !defined(NO_FILESYSTEMS)
/* Get file information, return 1 if file exists, 0 if not */
static int
mg_stat(const struct mg_connection *conn,
        const char *path,
        struct mg_file_stat *filep)
{
   wchar_t wbuf[UTF16_PATH_MAX];
   WIN32_FILE_ATTRIBUTE_DATA info;
   time_t creation_time;
   size_t len;
 
   if (!filep) {
      return 0;
   }
   memset(filep, 0, sizeof(*filep));
 
   if (mg_path_suspicious(conn, path)) {
      return 0;
   }
 
   path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf));
   /* Windows happily opens files with some garbage at the end of file name.
    * For example, fopen("a.cgi    ", "r") on Windows successfully opens
    * "a.cgi", despite one would expect an error back. */
   len = strlen(path);
   if ((len > 0) && (path[len - 1] != ' ') && (path[len - 1] != '.')
       && (GetFileAttributesExW(wbuf, GetFileExInfoStandard, &info) != 0)) {
      filep->size = MAKEUQUAD(info.nFileSizeLow, info.nFileSizeHigh);
      filep->last_modified =
          SYS2UNIX_TIME(info.ftLastWriteTime.dwLowDateTime,
                        info.ftLastWriteTime.dwHighDateTime);
 
      /* On Windows, the file creation time can be higher than the
       * modification time, e.g. when a file is copied.
       * Since the Last-Modified timestamp is used for caching
       * it should be based on the most recent timestamp. */
      creation_time = SYS2UNIX_TIME(info.ftCreationTime.dwLowDateTime,
                                    info.ftCreationTime.dwHighDateTime);
      if (creation_time > filep->last_modified) {
         filep->last_modified = creation_time;
      }
 
      filep->is_directory = info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
      return 1;
   }
 
   return 0;
}
#endif
 
 
static int
mg_remove(const struct mg_connection *conn, const char *path)
{
   wchar_t wbuf[UTF16_PATH_MAX];
   path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf));
   return DeleteFileW(wbuf) ? 0 : -1;
}
 
 
static int
mg_mkdir(const struct mg_connection *conn, const char *path, int mode)
{
   wchar_t wbuf[UTF16_PATH_MAX];
   (void)mode;
   path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf));
   return CreateDirectoryW(wbuf, NULL) ? 0 : -1;
}
 
 
/* Create substitutes for POSIX functions in Win32. */
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
 
/* Implementation of POSIX opendir/closedir/readdir for Windows. */
FUNCTION_MAY_BE_UNUSED
static DIR *
mg_opendir(const struct mg_connection *conn, const char *name)
{
   DIR *dir = NULL;
   wchar_t wpath[UTF16_PATH_MAX];
   DWORD attrs;
 
   if (name == NULL) {
      SetLastError(ERROR_BAD_ARGUMENTS);
   } else if ((dir = (DIR *)mg_malloc(sizeof(*dir))) == NULL) {
      SetLastError(ERROR_NOT_ENOUGH_MEMORY);
   } else {
      path_to_unicode(conn, name, wpath, ARRAY_SIZE(wpath));
      attrs = GetFileAttributesW(wpath);
      if ((wcslen(wpath) + 2 < ARRAY_SIZE(wpath)) && (attrs != 0xFFFFFFFF)
          && ((attrs & FILE_ATTRIBUTE_DIRECTORY) != 0)) {
         (void)wcscat(wpath, L"\\*");
         dir->handle = FindFirstFileW(wpath, &dir->info);
         dir->result.d_name[0] = '\0';
      } else {
         mg_free(dir);
         dir = NULL;
      }
   }
 
   return dir;
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
mg_closedir(DIR *dir)
{
   int result = 0;
 
   if (dir != NULL) {
      if (dir->handle != INVALID_HANDLE_VALUE)
         result = FindClose(dir->handle) ? 0 : -1;
 
      mg_free(dir);
   } else {
      result = -1;
      SetLastError(ERROR_BAD_ARGUMENTS);
   }
 
   return result;
}
 
 
FUNCTION_MAY_BE_UNUSED
static struct dirent *
mg_readdir(DIR *dir)
{
   struct dirent *result = 0;
 
   if (dir) {
      if (dir->handle != INVALID_HANDLE_VALUE) {
         result = &dir->result;
         (void)WideCharToMultiByte(CP_UTF8,
                                   0,
                                   dir->info.cFileName,
                                   -1,
                                   result->d_name,
                                   sizeof(result->d_name),
                                   NULL,
                                   NULL);
 
         if (!FindNextFileW(dir->handle, &dir->info)) {
            (void)FindClose(dir->handle);
            dir->handle = INVALID_HANDLE_VALUE;
         }
 
      } else {
         SetLastError(ERROR_FILE_NOT_FOUND);
      }
   } else {
      SetLastError(ERROR_BAD_ARGUMENTS);
   }
 
   return result;
}
 
 
#if !defined(HAVE_POLL)
#undef POLLIN
#undef POLLPRI
#undef POLLOUT
#undef POLLERR
#define POLLIN (1)  /* Data ready - read will not block. */
#define POLLPRI (2) /* Priority data ready. */
#define POLLOUT (4) /* Send queue not full - write will not block. */
#define POLLERR (8) /* Error event */
 
FUNCTION_MAY_BE_UNUSED
static int
poll(struct mg_pollfd *pfd, unsigned int n, int milliseconds)
{
   struct timeval tv;
   fd_set rset;
   fd_set wset;
   fd_set eset;
   unsigned int i;
   int result;
   SOCKET maxfd = 0;
 
   memset(&tv, 0, sizeof(tv));
   tv.tv_sec = milliseconds / 1000;
   tv.tv_usec = (milliseconds % 1000) * 1000;
   FD_ZERO(&rset);
   FD_ZERO(&wset);
   FD_ZERO(&eset);
 
   for (i = 0; i < n; i++) {
      if (pfd[i].events & (POLLIN | POLLOUT | POLLERR)) {
         if (pfd[i].events & POLLIN) {
            FD_SET(pfd[i].fd, &rset);
         }
         if (pfd[i].events & POLLOUT) {
            FD_SET(pfd[i].fd, &wset);
         }
         /* Check for errors for any FD in the set */
         FD_SET(pfd[i].fd, &eset);
      }
      pfd[i].revents = 0;
 
      if (pfd[i].fd > maxfd) {
         maxfd = pfd[i].fd;
      }
   }
 
   if ((result = select((int)maxfd + 1, &rset, &wset, &eset, &tv)) > 0) {
      for (i = 0; i < n; i++) {
         if (FD_ISSET(pfd[i].fd, &rset)) {
            pfd[i].revents |= POLLIN;
         }
         if (FD_ISSET(pfd[i].fd, &wset)) {
            pfd[i].revents |= POLLOUT;
         }
         if (FD_ISSET(pfd[i].fd, &eset)) {
            pfd[i].revents |= POLLERR;
         }
      }
   }
 
   /* We should subtract the time used in select from remaining
    * "milliseconds", in particular if called from mg_poll with a
    * timeout quantum.
    * Unfortunately, the remaining time is not stored in "tv" in all
    * implementations, so the result in "tv" must be considered undefined.
    * See http://man7.org/linux/man-pages/man2/select.2.html */
 
   return result;
}
#endif /* HAVE_POLL */
 
 
#if defined(GCC_DIAGNOSTIC)
/* Enable unused function warning again */
#pragma GCC diagnostic pop
#endif
 
 
static void
set_close_on_exec(SOCKET sock,
                  const struct mg_connection *conn /* may be null */,
                  struct mg_context *ctx /* may be null */)
{
   (void)conn; /* Unused. */
   (void)ctx;
 
   (void)SetHandleInformation((HANDLE)(intptr_t)sock, HANDLE_FLAG_INHERIT, 0);
}
 
 
int
mg_start_thread(mg_thread_func_t f, void *p)
{
#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
   /* Compile-time option to control stack size, e.g.
    * -DUSE_STACK_SIZE=16384
    */
   return ((_beginthread((void(__cdecl *)(void *))f, USE_STACK_SIZE, p)
            == ((uintptr_t)(-1L)))
               ? -1
               : 0);
#else
   return (
       (_beginthread((void(__cdecl *)(void *))f, 0, p) == ((uintptr_t)(-1L)))
           ? -1
           : 0);
#endif /* defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) */
}
 
 
/* Start a thread storing the thread context. */
static int
mg_start_thread_with_id(unsigned(__stdcall *f)(void *),
                        void *p,
                        pthread_t *threadidptr)
{
   uintptr_t uip;
   HANDLE threadhandle;
   int result = -1;
 
   uip = _beginthreadex(NULL, 0, f, p, 0, NULL);
   threadhandle = (HANDLE)uip;
   if ((uip != 0) && (threadidptr != NULL)) {
      *threadidptr = threadhandle;
      result = 0;
   }
 
   return result;
}
 
 
/* Wait for a thread to finish. */
static int
mg_join_thread(pthread_t threadid)
{
   int result;
   DWORD dwevent;
 
   result = -1;
   dwevent = WaitForSingleObject(threadid, (DWORD)INFINITE);
   if (dwevent == WAIT_FAILED) {
      DEBUG_TRACE("WaitForSingleObject() failed, error %d", ERRNO);
   } else {
      if (dwevent == WAIT_OBJECT_0) {
         CloseHandle(threadid);
         result = 0;
      }
   }
 
   return result;
}
 
#if !defined(NO_SSL_DL) && !defined(NO_SSL)
/* If SSL is loaded dynamically, dlopen/dlclose is required. */
/* Create substitutes for POSIX functions in Win32. */
 
#if defined(GCC_DIAGNOSTIC)
/* Show no warning in case system functions are not used. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
 
FUNCTION_MAY_BE_UNUSED
static HANDLE
dlopen(const char *dll_name, int flags)
{
   wchar_t wbuf[UTF16_PATH_MAX];
   (void)flags;
   path_to_unicode(NULL, dll_name, wbuf, ARRAY_SIZE(wbuf));
   return LoadLibraryW(wbuf);
}
 
 
FUNCTION_MAY_BE_UNUSED
static int
dlclose(void *handle)
{
   int result;
 
   if (FreeLibrary((HMODULE)handle) != 0) {
      result = 0;
   } else {
      result = -1;
   }
 
   return result;
}
 
 
#if defined(GCC_DIAGNOSTIC)
/* Enable unused function warning again */
#pragma GCC diagnostic pop
#endif
 
#endif
 
 
#if !defined(NO_CGI)
#define SIGKILL (0)
 
 
static int
kill(pid_t pid, int sig_num)
{
   (void)TerminateProcess((HANDLE)pid, (UINT)sig_num);
   (void)CloseHandle((HANDLE)pid);
   return 0;
}
 
 
#if !defined(WNOHANG)
#define WNOHANG (1)
#endif
 
 
static pid_t
waitpid(pid_t pid, int *status, int flags)
{
   DWORD timeout = INFINITE;
   DWORD waitres;
 
   (void)status; /* Currently not used by any client here */
 
   if ((flags | WNOHANG) == WNOHANG) {
      timeout = 0;
   }
 
   waitres = WaitForSingleObject((HANDLE)pid, timeout);
   if (waitres == WAIT_OBJECT_0) {
      return pid;
   }
   if (waitres == WAIT_TIMEOUT) {
      return 0;
   }
   return (pid_t)-1;
}
 
 
static void
trim_trailing_whitespaces(char *s)
{
   char *e = s + strlen(s);
   while ((e > s) && isspace((unsigned char)e[-1])) {
      *(--e) = '\0';
   }
}
 
 
static pid_t
spawn_process(struct mg_connection *conn,
              const char *prog,
              char *envblk,
              char *envp[],
              int fdin[2],
              int fdout[2],
              int fderr[2],
              const char *dir,
              unsigned char cgi_config_idx)
{
   HANDLE me;
   char *interp;
   char *interp_arg = 0;
   char full_dir[UTF8_PATH_MAX], cmdline[UTF8_PATH_MAX], buf[UTF8_PATH_MAX];
   int truncated;
   struct mg_file file = STRUCT_FILE_INITIALIZER;
   STARTUPINFOA si;
   PROCESS_INFORMATION pi = {0};
 
   (void)envp;
 
   memset(&si, 0, sizeof(si));
   si.cb = sizeof(si);
 
   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
   si.wShowWindow = SW_HIDE;
 
   me = GetCurrentProcess();
   DuplicateHandle(me,
                   (HANDLE)_get_osfhandle(fdin[0]),
                   me,
                   &si.hStdInput,
                   0,
                   TRUE,
                   DUPLICATE_SAME_ACCESS);
   DuplicateHandle(me,
                   (HANDLE)_get_osfhandle(fdout[1]),
                   me,
                   &si.hStdOutput,
                   0,
                   TRUE,
                   DUPLICATE_SAME_ACCESS);
   DuplicateHandle(me,
                   (HANDLE)_get_osfhandle(fderr[1]),
                   me,
                   &si.hStdError,
                   0,
                   TRUE,
                   DUPLICATE_SAME_ACCESS);
 
   /* Mark handles that should not be inherited. See
    * https://msdn.microsoft.com/en-us/library/windows/desktop/ms682499%28v=vs.85%29.aspx
    */
   SetHandleInformation((HANDLE)_get_osfhandle(fdin[1]),
                        HANDLE_FLAG_INHERIT,
                        0);
   SetHandleInformation((HANDLE)_get_osfhandle(fdout[0]),
                        HANDLE_FLAG_INHERIT,
                        0);
   SetHandleInformation((HANDLE)_get_osfhandle(fderr[0]),
                        HANDLE_FLAG_INHERIT,
                        0);
 
   /* First check, if there is a CGI interpreter configured for all CGI
    * scripts. */
   interp = conn->dom_ctx->config[CGI_INTERPRETER + cgi_config_idx];
   if (interp != NULL) {
      /* If there is a configured interpreter, check for additional arguments
       */
      interp_arg =
          conn->dom_ctx->config[CGI_INTERPRETER_ARGS + cgi_config_idx];
   } else {
      /* Otherwise, the interpreter must be stated in the first line of the
       * CGI script file, after a #! (shebang) mark. */
      buf[0] = buf[1] = '\0';
 
      /* Get the full script path */
      mg_snprintf(
          conn, &truncated, cmdline, sizeof(cmdline), "%s/%s", dir, prog);
 
      if (truncated) {
         pi.hProcess = (pid_t)-1;
         goto spawn_cleanup;
      }
 
      /* Open the script file, to read the first line */
      if (mg_fopen(conn, cmdline, MG_FOPEN_MODE_READ, &file)) {
 
         /* Read the first line of the script into the buffer */
         mg_fgets(buf, sizeof(buf), &file);
         (void)mg_fclose(&file.access); /* ignore error on read only file */
         buf[sizeof(buf) - 1] = '\0';
      }
 
      if ((buf[0] == '#') && (buf[1] == '!')) {
         trim_trailing_whitespaces(buf + 2);
      } else {
         buf[2] = '\0';
      }
      interp = buf + 2;
   }
 
   GetFullPathNameA(dir, sizeof(full_dir), full_dir, NULL);
 
   if (interp[0] != '\0') {
      /* This is an interpreted script file. We must call the interpreter. */
      if ((interp_arg != 0) && (interp_arg[0] != 0)) {
         mg_snprintf(conn,
                     &truncated,
                     cmdline,
                     sizeof(cmdline),
                     "\"%s\" %s \"%s\\%s\"",
                     interp,
                     interp_arg,
                     full_dir,
                     prog);
      } else {
         mg_snprintf(conn,
                     &truncated,
                     cmdline,
                     sizeof(cmdline),
                     "\"%s\" \"%s\\%s\"",
                     interp,
                     full_dir,
                     prog);
      }
   } else {
      /* This is (probably) a compiled program. We call it directly. */
      mg_snprintf(conn,
                  &truncated,
                  cmdline,
                  sizeof(cmdline),
                  "\"%s\\%s\"",
                  full_dir,
                  prog);
   }
 
   if (truncated) {
      pi.hProcess = (pid_t)-1;
      goto spawn_cleanup;
   }
 
   DEBUG_TRACE("Running [%s]", cmdline);
   if (CreateProcessA(NULL,
                      cmdline,
                      NULL,
                      NULL,
                      TRUE,
                      CREATE_NEW_PROCESS_GROUP,
                      envblk,
                      NULL,
                      &si,
                      &pi)
       == 0) {
      mg_cry_internal(
          conn, "%s: CreateProcess(%s): %ld", __func__, cmdline, (long)ERRNO);
      pi.hProcess = (pid_t)-1;
      /* goto spawn_cleanup; */
   }
 
spawn_cleanup:
   (void)CloseHandle(si.hStdOutput);
   (void)CloseHandle(si.hStdError);
   (void)CloseHandle(si.hStdInput);
   if (pi.hThread != NULL) {
      (void)CloseHandle(pi.hThread);
   }
 
   return (pid_t)pi.hProcess;
}
#endif /* !NO_CGI */
 
 
static int
set_blocking_mode(SOCKET sock)
{
   unsigned long non_blocking = 0;
   return ioctlsocket(sock, (long)FIONBIO, &non_blocking);
}
 
 
static int
set_non_blocking_mode(SOCKET sock)
{
   unsigned long non_blocking = 1;
   return ioctlsocket(sock, (long)FIONBIO, &non_blocking);
}
 
 
#else
 
 
#if !defined(NO_FILESYSTEMS)
static int
mg_stat(const struct mg_connection *conn,
        const char *path,
        struct mg_file_stat *filep)
{
   struct stat st;
   if (!filep) {
      return 0;
   }
   memset(filep, 0, sizeof(*filep));
 
   if (mg_path_suspicious(conn, path)) {
      return 0;
   }
 
   if (0 == stat(path, &st)) {
      filep->size = (uint64_t)(st.st_size);
      filep->last_modified = st.st_mtime;
      filep->is_directory = S_ISDIR(st.st_mode);
      return 1;
   }
 
   return 0;
}
#endif /* NO_FILESYSTEMS */
 
 
static void
set_close_on_exec(int fd,
                  const struct mg_connection *conn /* may be null */,
                  struct mg_context *ctx /* may be null */)
{
#if defined(__ZEPHYR__)
   (void)fd;
   (void)conn;
   (void)ctx;
#else
   if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {
      if (conn || ctx) {
         struct mg_connection fc;
         mg_cry_internal((conn ? conn : fake_connection(&fc, ctx)),
                         "%s: fcntl(F_SETFD FD_CLOEXEC) failed: %s",
                         __func__,
                         strerror(ERRNO));
      }
   }
#endif
}
 
 
int
mg_start_thread(mg_thread_func_t func, void *param)
{
   pthread_t thread_id;
   pthread_attr_t attr;
   int result;
 
   (void)pthread_attr_init(&attr);
   (void)pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
#if defined(__ZEPHYR__)
   pthread_attr_setstack(&attr, &civetweb_main_stack, ZEPHYR_STACK_SIZE);
#elif defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
   /* Compile-time option to control stack size,
    * e.g. -DUSE_STACK_SIZE=16384 */
   (void)pthread_attr_setstacksize(&attr, USE_STACK_SIZE);
#endif /* defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) */
 
   result = pthread_create(&thread_id, &attr, func, param);
   pthread_attr_destroy(&attr);
 
   return result;
}
 
 
/* Start a thread storing the thread context. */
static int
mg_start_thread_with_id(mg_thread_func_t func,
                        void *param,
                        pthread_t *threadidptr)
{
   pthread_t thread_id;
   pthread_attr_t attr;
   int result;
 
   (void)pthread_attr_init(&attr);
 
#if defined(__ZEPHYR__)
   pthread_attr_setstack(&attr,
                         &civetweb_worker_stacks[zephyr_worker_stack_index++],
                         ZEPHYR_STACK_SIZE);
#elif defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
   /* Compile-time option to control stack size,
    * e.g. -DUSE_STACK_SIZE=16384 */
   (void)pthread_attr_setstacksize(&attr, USE_STACK_SIZE);
#endif /* defined(USE_STACK_SIZE) && USE_STACK_SIZE > 1 */
 
   result = pthread_create(&thread_id, &attr, func, param);
   pthread_attr_destroy(&attr);
   if ((result == 0) && (threadidptr != NULL)) {
      *threadidptr = thread_id;
   }
   return result;
}
 
 
/* Wait for a thread to finish. */
static int
mg_join_thread(pthread_t threadid)
{
   int result;
 
   result = pthread_join(threadid, NULL);
   return result;
}
 
 
#if !defined(NO_CGI)
static pid_t
spawn_process(struct mg_connection *conn,
              const char *prog,
              char *envblk,
              char *envp[],
              int fdin[2],
              int fdout[2],
              int fderr[2],
              const char *dir,
              unsigned char cgi_config_idx)
{
   pid_t pid;
   const char *interp;
 
   (void)envblk;
 
   if ((pid = fork()) == -1) {
      /* Parent */
      mg_cry_internal(conn, "%s: fork(): %s", __func__, strerror(ERRNO));
   } else if (pid != 0) {
      /* Make sure children close parent-side descriptors.
       * The caller will close the child-side immediately. */
      set_close_on_exec(fdin[1], conn, NULL);  /* stdin write */
      set_close_on_exec(fdout[0], conn, NULL); /* stdout read */
      set_close_on_exec(fderr[0], conn, NULL); /* stderr read */
   } else {
      /* Child */
      if (chdir(dir) != 0) {
         mg_cry_internal(
             conn, "%s: chdir(%s): %s", __func__, dir, strerror(ERRNO));
      } else if (dup2(fdin[0], 0) == -1) {
         mg_cry_internal(conn,
                         "%s: dup2(%d, 0): %s",
                         __func__,
                         fdin[0],
                         strerror(ERRNO));
      } else if (dup2(fdout[1], 1) == -1) {
         mg_cry_internal(conn,
                         "%s: dup2(%d, 1): %s",
                         __func__,
                         fdout[1],
                         strerror(ERRNO));
      } else if (dup2(fderr[1], 2) == -1) {
         mg_cry_internal(conn,
                         "%s: dup2(%d, 2): %s",
                         __func__,
                         fderr[1],
                         strerror(ERRNO));
      } else {
         struct sigaction sa;
 
         /* Keep stderr and stdout in two different pipes.
          * Stdout will be sent back to the client,
          * stderr should go into a server error log. */
         (void)close(fdin[0]);
         (void)close(fdout[1]);
         (void)close(fderr[1]);
 
         /* Close write end fdin and read end fdout and fderr */
         (void)close(fdin[1]);
         (void)close(fdout[0]);
         (void)close(fderr[0]);
 
         /* After exec, all signal handlers are restored to their default
          * values, with one exception of SIGCHLD. According to
          * POSIX.1-2001 and Linux's implementation, SIGCHLD's handler
          * will leave unchanged after exec if it was set to be ignored.
          * Restore it to default action. */
         memset(&sa, 0, sizeof(sa));
         sa.sa_handler = SIG_DFL;
         sigaction(SIGCHLD, &sa, NULL);
 
         interp = conn->dom_ctx->config[CGI_INTERPRETER + cgi_config_idx];
         if (interp == NULL) {
            /* no interpreter configured, call the programm directly */
            (void)execle(prog, prog, NULL, envp);
            mg_cry_internal(conn,
                            "%s: execle(%s): %s",
                            __func__,
                            prog,
                            strerror(ERRNO));
         } else {
            /* call the configured interpreter */
            const char *interp_args =
                conn->dom_ctx
                    ->config[CGI_INTERPRETER_ARGS + cgi_config_idx];
 
            if ((interp_args != NULL) && (interp_args[0] != 0)) {
               (void)execle(interp, interp, interp_args, prog, NULL, envp);
            } else {
               (void)execle(interp, interp, prog, NULL, envp);
            }
            mg_cry_internal(conn,
                            "%s: execle(%s %s): %s",
                            __func__,
                            interp,
                            prog,
                            strerror(ERRNO));
         }
      }
      exit(EXIT_FAILURE);
   }
 
   return pid;
}
#endif /* !NO_CGI */
 
 
static int
set_non_blocking_mode(SOCKET sock)
{
   int flags = fcntl(sock, F_GETFL, 0);
   if (flags < 0) {
      return -1;
   }
 
   if (fcntl(sock, F_SETFL, (flags | O_NONBLOCK)) < 0) {
      return -1;
   }
   return 0;
}
 
static int
set_blocking_mode(SOCKET sock)
{
   int flags = fcntl(sock, F_GETFL, 0);
   if (flags < 0) {
      return -1;
   }
 
   if (fcntl(sock, F_SETFL, flags & (~(int)(O_NONBLOCK))) < 0) {
      return -1;
   }
   return 0;
}
#endif /* _WIN32 / else */
 
/* End of initial operating system specific define block. */
 
 
/* Get a random number (independent of C rand function) */
static uint64_t
get_random(void)
{
   static uint64_t lfsr = 0; /* Linear feedback shift register */
   static uint64_t lcg = 0;  /* Linear congruential generator */
   uint64_t now = mg_get_current_time_ns();
 
   if (lfsr == 0) {
      /* lfsr will be only 0 if has not been initialized,
       * so this code is called only once. */
      lfsr = mg_get_current_time_ns();
      lcg = mg_get_current_time_ns();
   } else {
      /* Get the next step of both random number generators. */
      lfsr = (lfsr >> 1)
             | ((((lfsr >> 0) ^ (lfsr >> 1) ^ (lfsr >> 3) ^ (lfsr >> 4)) & 1)
                << 63);
      lcg = lcg * 6364136223846793005LL + 1442695040888963407LL;
   }
 
   /* Combining two pseudo-random number generators and a high resolution
    * part
    * of the current server time will make it hard (impossible?) to guess
    * the
    * next number. */
   return (lfsr ^ lcg ^ now);
}
 
 
static int
mg_poll(struct mg_pollfd *pfd,
        unsigned int n,
        int milliseconds,
        const stop_flag_t *stop_flag)
{
   /* Call poll, but only for a maximum time of a few seconds.
    * This will allow to stop the server after some seconds, instead
    * of having to wait for a long socket timeout. */
   int ms_now = SOCKET_TIMEOUT_QUANTUM; /* Sleep quantum in ms */
 
   int check_pollerr = 0;
   if ((n == 1) && ((pfd[0].events & POLLERR) == 0)) {
      /* If we wait for only one file descriptor, wait on error as well */
      pfd[0].events |= POLLERR;
      check_pollerr = 1;
   }
 
   do {
      int result;
 
      if (!STOP_FLAG_IS_ZERO(&*stop_flag)) {
         /* Shut down signal */
         return -2;
      }
 
      if ((milliseconds >= 0) && (milliseconds < ms_now)) {
         ms_now = milliseconds;
      }
 
      result = poll(pfd, n, ms_now);
      if (result != 0) {
         /* Poll returned either success (1) or error (-1).
          * Forward both to the caller. */
         if ((check_pollerr)
             && ((pfd[0].revents & (POLLIN | POLLOUT | POLLERR))
                 == POLLERR)) {
            /* One and only file descriptor returned error */
            return -1;
         }
         return result;
      }
 
      /* Poll returned timeout (0). */
      if (milliseconds > 0) {
         milliseconds -= ms_now;
      }
 
   } while (milliseconds > 0);
 
   /* timeout: return 0 */
   return 0;
}
 
 
/* Write data to the IO channel - opened file descriptor, socket or SSL
 * descriptor.
 * Return value:
 *  >=0 .. number of bytes successfully written
 *   -1 .. timeout
 *   -2 .. error
 */
static int
push_inner(struct mg_context *ctx,
           FILE *fp,
           SOCKET sock,
           SSL *ssl,
           const char *buf,
           int len,
           double timeout)
{
   uint64_t start = 0, now = 0, timeout_ns = 0;
   int n, err;
   unsigned ms_wait = SOCKET_TIMEOUT_QUANTUM; /* Sleep quantum in ms */
 
#if defined(_WIN32)
   typedef int len_t;
#else
   typedef size_t len_t;
#endif
 
   if (timeout > 0) {
      now = mg_get_current_time_ns();
      start = now;
      timeout_ns = (uint64_t)(timeout * 1.0E9);
   }
 
   if (ctx == NULL) {
      return -2;
   }
 
#if defined(NO_SSL) && !defined(USE_MBEDTLS)
   if (ssl) {
      return -2;
   }
#endif
 
   /* Try to read until it succeeds, fails, times out, or the server
    * shuts down. */
   for (;;) {
 
#if defined(USE_MBEDTLS)
      if (ssl != NULL) {
         n = mbed_ssl_write(ssl, (const unsigned char *)buf, len);
         if (n <= 0) {
            if ((n == MBEDTLS_ERR_SSL_WANT_READ)
                || (n == MBEDTLS_ERR_SSL_WANT_WRITE)